├── .gitignore ├── MainCompile.sh ├── MainRun.sh ├── README.md ├── code-set ├── 01.java ├── 02.java ├── 03.java ├── 04.java ├── 05.java ├── 06.java ├── 07.java ├── 08.java ├── 09.java ├── 10.java ├── 100.cpp ├── 11.cpp ├── 11.java ├── 12.java ├── 13.java ├── 14.java ├── 15.java ├── 16.cpp ├── 17.java ├── 18.java ├── 19.java ├── 20.java ├── 21.java ├── 22.java ├── 24.cpp ├── 25.java ├── 26.cpp ├── 27.java ├── 28.java ├── 29.cpp ├── 30.java ├── 33.java ├── 34.java ├── 35.java ├── 37.cpp ├── 41.java ├── 43.cpp ├── 44.cpp ├── 45.java ├── 46.cpp ├── 47.cpp ├── 48.cpp ├── 50.cpp ├── 51.cpp ├── 52.cpp ├── 53.cpp ├── 56.cpp ├── 57.cpp ├── 61.cpp ├── 62.cpp ├── 66.java ├── 69.cpp ├── 70.cpp ├── 71.cpp ├── 72.cpp ├── 91.cpp ├── 94.cpp └── 96.cpp ├── draft ├── 19.cpp └── solution032.md ├── make.sh ├── solutions ├── solution000.md ├── solution001.md ├── solution002.md ├── solution003.md ├── solution004.md ├── solution005.md ├── solution006.md ├── solution007.md ├── solution008.md ├── solution009.md ├── solution010.md ├── solution011.md ├── solution012.md ├── solution013.md ├── solution014.md ├── solution015.md ├── solution016.md ├── solution017.md ├── solution018.md ├── solution019.md ├── solution020.md ├── solution021.md ├── solution022.md ├── solution023.md ├── solution024.md ├── solution025.md ├── solution027.md ├── solution028.md ├── solution029.md ├── solution030.md ├── solution033.md ├── solution034.md ├── solution035.md ├── solution037.md ├── solution041.md ├── solution043.md ├── solution045.md ├── solution046.md ├── solution047.md ├── solution048.md ├── solution050.md ├── solution051.md ├── solution052.md ├── solution053.md ├── solution061.md ├── solution062.md ├── solution066.md ├── solution069.md ├── solution070.md ├── solution071.md ├── solution072.md └── solution100.md └── spider.py /.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | out/ 3 | .idea/ 4 | .iml 5 | src 6 | 7 | .vs 8 | .vscode -------------------------------------------------------------------------------- /MainCompile.sh: -------------------------------------------------------------------------------- 1 | # java程序的编译脚本，适用于linux平台 2 | PROJECT_DIR=/home/ysxiang/workspace/java_project/algorithm 3 | # clean target directory 4 | rm -rf $PROJECT_DIR/target/* 5 | 6 | # prepare arg files 7 | find $PROJECT_DIR/src -name "*.java">$PROJECT_DIR/target/javaFiles.txt 8 | echo "-d $PROJECT_DIR/target" >$PROJECT_DIR/target/javaOptions.txt 9 | # compile 10 | javac @$PROJECT_DIR/target/javaOptions.txt @$PROJECT_DIR/target/javaFiles.txt 11 | 12 | # clean temp files 13 | rm -rf $PROJECT_DIR/target/javaOptions.txt $PROJECT_DIR/target/javaFiles.txt% -------------------------------------------------------------------------------- /MainRun.sh: -------------------------------------------------------------------------------- 1 | java -cp target Main -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 主要目的是用来备份代码以及linux端与windows端代码的同步 4 | 5 | 题解目录 `./solutions` 6 | 7 | 未AC的代码 `./draft` 8 | 9 | 题解代码目录 `./code-set` [题解代码获得脚本](https://github.com/2ndelement/OJ-ANS/blob/master/spider.py) -------------------------------------------------------------------------------- /code-set/01.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | public static void main(String arg[]) { 5 | Scanner snc = new Scanner(System.in); 6 | int n = snc.nextInt(); 7 | 8 | int arr[] = new int[n]; 9 | for (int i = 0; i < n; i++) { 10 | arr[i] = snc.nextInt(); 11 | } 12 | Main main = new Main(); 13 | System.out.println(main.hIndex(arr)); 14 | } 15 | 16 | public int hIndex(int[] citations) { 17 | // method 1: 排序 18 | Arrays.sort(citations); 19 | int iter = citations.length - 1; 20 | int hIndex = 0; 21 | while (iter >= 0 && citations[iter] > hIndex) { // 如果citations[iter] > hIndex，则说明第iter + 1篇论文的引用数大于 h，符合条件，继续往下搜索。 22 | hIndex++; 23 | iter--; 24 | } 25 | return hIndex; 26 | } 27 | } -------------------------------------------------------------------------------- /code-set/02.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | public static void main(String arg[]) { 5 | Scanner snc = new Scanner(System.in); 6 | 7 | int n = snc.nextInt(); 8 | int k = snc.nextInt(); 9 | int[] nums = new int[n]; 10 | for (int i = 0; i < n; i++) { 11 | nums[i] = snc.nextInt(); 12 | } 13 | System.out.println(k_dis(nums, k)); 14 | } 15 | 16 | /** 17 | * 利用HashMap方法 18 | * @param nums 19 | * @param k 20 | * @return 21 | */ 22 | public static int k_dis(int[] nums, int k) { 23 | int count = 0; 24 | int length = nums.length; 25 | HashMap hashMap = new HashMap(); 26 | for (int iter = 0; iter < length; iter++) { 27 | count += hashMap.getOrDefault( nums[iter] - k, 0) + hashMap.getOrDefault(nums[iter] + k, 0); 28 | hashMap.put(nums[iter], hashMap.getOrDefault(nums[iter], 0) + 1); 29 | } 30 | return count; 31 | } 32 | } -------------------------------------------------------------------------------- /code-set/03.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | public static void main(String arg[]) { 5 | Scanner snc = new Scanner(System.in); 6 | int n = snc.nextInt(); 7 | System.out.println(totalMoney(n)); 8 | } 9 | 10 | public static int totalMoney(int n) { 11 | int week = n / 7; 12 | int day = n % 7; 13 | int total = 0; 14 | total = 28 * week + week * (week - 1) * 7 / 2; 15 | for (int iter = 0; iter < day; iter++) { 16 | total += week + iter + 1; 17 | } 18 | return total; 19 | } 20 | } -------------------------------------------------------------------------------- /code-set/04.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | 8 | public static void main(String arg[]) { 9 | Scanner snc = new Scanner(System.in); 10 | int n = snc.nextInt(); 11 | System.out.println(maximumEvenSplit(n)); 12 | } 13 | 14 | public static List maximumEvenSplit(long finalSum) { 15 | ArrayList list = new ArrayList(); 16 | if (finalSum % 2 == 0) { 17 | long base = 2; 18 | list.add(base); 19 | finalSum = finalSum - 2; 20 | while (list.get(list.size() - 1) < finalSum) { 21 | base = base + 2; 22 | finalSum = finalSum - base; 23 | list.add(base); 24 | } 25 | list.set(list.size() - 1, list.get(list.size() - 1) + finalSum); 26 | } 27 | return list; 28 | } 29 | } -------------------------------------------------------------------------------- /code-set/05.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | public static void main(String[] args) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | Main main = new Main(); 11 | System.out.println(main.countDigitOne(n)); 12 | } 13 | 14 | /** 15 | * 计算1的个数 16 | * @param n 17 | * @return 18 | */ 19 | public int countDigitOne(int n) { 20 | String nString = String.valueOf(n); 21 | int nLength = nString.length(); 22 | if (nLength == 1) { 23 | if (n > 0) { 24 | return 1; 25 | } else { 26 | return 0; 27 | } 28 | } 29 | // 计算第i位前的数值，和第i位后的数值 30 | // 例如 abcde 则有 before[2] = ab; behind[2] = de 31 | int[] before = new int[nLength]; 32 | int[] behind = new int[nLength]; 33 | behind[0] = Integer.parseInt(nString.substring(1)); 34 | for (int iter = 1; iter < nLength - 1; iter++) { 35 | before[iter] = Integer.parseInt(nString.substring(0, iter)); 36 | behind[iter] = Integer.parseInt(nString.substring(iter + 1)); 37 | } 38 | before[nLength - 1] = Integer.parseInt(nString.substring(0, nLength - 1)); 39 | 40 | int digitOneCount = 0; 41 | for (int iter = 0; iter < nLength; iter++) { 42 | // x 为当前位数值，len 为当前位后面长度为多少 43 | int x = nString.charAt(iter) - '0'; 44 | int len = nLength - iter - 1; 45 | int prefix = before[iter]; 46 | int suffix = behind[iter]; 47 | int total = 0; 48 | // 当 c 前面的部分小于 ab 时 49 | total += prefix * intPow10(len); 50 | if (x == 0) { 51 | 52 | } else if (x == 1) { 53 | total += suffix + 1; 54 | } else { 55 | total += intPow10(len); 56 | } 57 | digitOneCount += total; 58 | } 59 | return digitOneCount; 60 | } 61 | 62 | /** 63 | * 等价于 pow(10, index) 64 | * @param index 65 | * @return 66 | */ 67 | public int intPow10 (int index) { 68 | if (index == 0) { 69 | return 1; 70 | } else { 71 | int powResult = 1; 72 | while (index > 0) { 73 | powResult *= 10; 74 | index--; 75 | } 76 | return powResult; 77 | } 78 | } 79 | } -------------------------------------------------------------------------------- /code-set/06.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | public static void main(String arg[]) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | Main main = new Main(); 11 | System.out.println(main.consecutiveNumbersSum(n)); 12 | } 13 | 14 | /** 15 | * 设连续数列首项为a，公差为1，共k项。 16 | * 有 ka + k * (k - 1) /2 = n 17 | * k ^ 2 + 2 * k * a- k = 2n 18 | * 2a = 2n/k - k + 1 >= 2 19 | * @param n 20 | * @return 21 | */ 22 | public int consecutiveNumbersSum(int n) { 23 | int count = 0; 24 | int nMulti2 = n * 2; 25 | for (int k = 1; k * k < nMulti2; k++) { 26 | if (nMulti2 % k != 0) { 27 | continue; 28 | } 29 | if ((nMulti2 / k - k + 1) % 2 ==0) { 30 | count++; 31 | } 32 | } 33 | return count; 34 | } 35 | } -------------------------------------------------------------------------------- /code-set/07.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | 8 | public static void main(String arg[]) { 9 | Scanner snc = new Scanner(System.in); 10 | int n = snc.nextInt(); 11 | int k = snc.nextInt(); 12 | Main main = new Main(); 13 | System.out.println(main.minimumNumbers(n, k)); 14 | } 15 | 16 | public int minimumNumbers(int num, int k) { 17 | if (num == 0) { 18 | return 0; 19 | } else { 20 | for (int iter = 1; iter <= 10; iter++) { 21 | if (iter * k <= num && (num - iter * k) % 10 == 0) { 22 | return iter; 23 | } 24 | } 25 | return -1; 26 | } 27 | } 28 | } -------------------------------------------------------------------------------- /code-set/08.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | 8 | private HashSet hashSet = new HashSet(); 9 | 10 | public static void main(String arg[]) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | Main main = new Main(); 14 | System.out.println(main.reorderedPowerOf2(n)); 15 | } 16 | 17 | public boolean reorderedPowerOf2(int n) { 18 | for (int num = 1; num <= (int)1e9; num <<= 1) { 19 | hashSet.add(countDigits(num)); 20 | } 21 | return hashSet.contains(countDigits(n)); 22 | } 23 | 24 | public String countDigits(int num) { 25 | char[] countDigitsResult = new char[10]; 26 | while (num > 0) { 27 | countDigitsResult[num % 10]++; 28 | num = num / 10; 29 | } 30 | return new String(countDigitsResult); 31 | } 32 | } 33 | 34 | 35 | // 36 | // _oo0oo_ 37 | // o8888888o 38 | // 88" . "88 39 | // (| -_- |) 40 | // 0\ = /0 41 | // ___/`---'\___ 42 | // .' \\| |// '. 43 | // / \\||| : |||// \ 44 | // / _||||| -:- |||||- \ 45 | // | | \\\ - /// | | 46 | // | \_| ''\---/'' |_/ | 47 | // \ .-\__ '-' ___/-. / 48 | // ___'. .' /--.--\ `. .'___ 49 | // ."" '< `.___\_<|>_/___.' >' "". 50 | // | | : `- \`.;`\ _ /`;.`/ - ` : | | 51 | // \ \ `_. \_ __\ /__ _/ .-` / / 52 | // =====`-.____`.___ \_____/___.-`___.-'===== 53 | // `=---=' 54 | // 55 | // 56 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 57 | // 58 | // 佛祖保佑 永无BUG 59 | // -------------------------------------------------------------------------------- /code-set/09.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | 5 | public static void main(String arg[]) { 6 | Scanner snc = new Scanner(System.in); 7 | int n = snc.nextInt(); 8 | int arr[] = new int[n]; 9 | for (int i = 0; i < n; i++) { 10 | arr[i] = snc.nextInt(); 11 | } 12 | Main main = new Main(); 13 | System.out.println(main.maximumGap(arr)); 14 | } 15 | 16 | public int maximumGap(int[] nums) { 17 | Arrays.sort(nums); 18 | int maxGap = 0; 19 | for (int iter = 0; iter < nums.length - 1; iter++) { 20 | if (nums[iter + 1] - nums[iter] > maxGap) { 21 | maxGap = nums[iter + 1] - nums[iter]; 22 | } 23 | } 24 | return maxGap; 25 | } 26 | } 27 | 28 | 29 | // 30 | // _oo0oo_ 31 | // o8888888o 32 | // 88" . "88 33 | // (| -_- |) 34 | // 0\ = /0 35 | // ___/`---'\___ 36 | // .' \\| |// '. 37 | // / \\||| : |||// \ 38 | // / _||||| -:- |||||- \ 39 | // | | \\\ - /// | | 40 | // | \_| ''\---/'' |_/ | 41 | // \ .-\__ '-' ___/-. / 42 | // ___'. .' /--.--\ `. .'___ 43 | // ."" '< `.___\_<|>_/___.' >' "". 44 | // | | : `- \`.;`\ _ /`;.`/ - ` : | | 45 | // \ \ `_. \_ __\ /__ _/ .-` / / 46 | // =====`-.____`.___ \_____/___.-`___.-'===== 47 | // `=---=' 48 | // 49 | // 50 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 51 | // 52 | // 佛祖保佑 永无BUG 53 | // -------------------------------------------------------------------------------- /code-set/10.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | import java.util.*; 7 | 8 | public class Main { 9 | public static void main(String arg[]) { 10 | Scanner snc =new Scanner(System.in); 11 | int n =snc.nextInt(); 12 | Main main=new Main(); 13 | System.out.println(main.convertToTitle(n)); 14 | } 15 | 16 | public String convertToTitle(int columnNumber) { 17 | StringBuffer title = new StringBuffer(); 18 | while (columnNumber > 0) { 19 | title.insert(0, String.valueOf((char) ((columnNumber - 1) % 26 + Integer.valueOf('A')))); 20 | columnNumber = (columnNumber - 1)/ 26; 21 | } 22 | return new String(title); 23 | } 24 | } 25 | 26 | 27 | // 28 | // _oo0oo_ 29 | // o8888888o 30 | // 88" . "88 31 | // (| -_- |) 32 | // 0\ = /0 33 | // ___/`---'\___ 34 | // .' \\| |// '. 35 | // / \\||| : |||// \ 36 | // / _||||| -:- |||||- \ 37 | // | | \\\ - /// | | 38 | // | \_| ''\---/'' |_/ | 39 | // \ .-\__ '-' ___/-. / 40 | // ___'. .' /--.--\ `. .'___ 41 | // ."" '< `.___\_<|>_/___.' >' "". 42 | // | | : `- \`.;`\ _ /`;.`/ - ` : | | 43 | // \ \ `_. \_ __\ /__ _/ .-` / / 44 | // =====`-.____`.___ \_____/___.-`___.-'===== 45 | // `=---=' 46 | // 47 | // 48 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 49 | // 50 | // 佛祖保佑 永无BUG 51 | // -------------------------------------------------------------------------------- /code-set/100.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | static constexpr int TARGET = 24; 7 | static constexpr double EPSILON = 1e-6; 8 | static constexpr int ADD = 0, MULTIPLY = 1, SUBTRACT = 2, DIVIDE = 3; 9 | 10 | bool solve(vector& nums) 11 | { 12 | if (nums.size() == 0) { 13 | return false; 14 | } 15 | if (nums.size() == 1) { 16 | return fabs(nums[0] - TARGET) < EPSILON; 17 | } 18 | int nums_length = nums.size(); 19 | for (int iter = 0; iter < nums_length; iter++) { 20 | for (int jter = 0; jter < nums_length; jter++) { 21 | if (iter != jter) { 22 | vector list2; 23 | for (int kter = 0; kter < nums_length; kter++) { 24 | if (kter != iter && kter != jter) { 25 | list2.emplace_back(nums[kter]); 26 | } 27 | } 28 | for (int kter = 0; kter < 4; kter++) { 29 | if (kter < 2 && iter > jter) { 30 | continue; 31 | } 32 | switch (kter) { 33 | case ADD: 34 | list2.emplace_back(nums[iter] + nums[jter]); 35 | break; 36 | case MULTIPLY: 37 | list2.emplace_back(nums[iter] * nums[jter]); 38 | break; 39 | case SUBTRACT: 40 | list2.emplace_back(nums[iter] - nums[jter]); 41 | break; 42 | case DIVIDE: 43 | if (fabs(nums[jter]) < EPSILON) { 44 | continue; 45 | } 46 | list2.emplace_back(nums[iter] / nums[jter]); 47 | break; 48 | default: 49 | break; 50 | } 51 | if (solve(list2)) { 52 | return true; 53 | } 54 | list2.pop_back(); 55 | } 56 | } 57 | } 58 | } 59 | return false; 60 | } 61 | 62 | bool judgePoint24(vector& nums) 63 | { 64 | vector double_nums; 65 | for (const int& num : nums) { 66 | double_nums.emplace_back(static_cast(num)); 67 | } 68 | return solve(double_nums); 69 | } 70 | 71 | void solution100() 72 | { 73 | vector nums(4); 74 | for (vector::iterator iter = nums.begin(); iter < nums.end(); iter++) { 75 | cin >> *(iter); 76 | } 77 | cout << (judgePoint24(nums) ? "true" : "false") << endl; 78 | } 79 | 80 | int main() 81 | { 82 | solution100(); 83 | return 0; 84 | } -------------------------------------------------------------------------------- /code-set/11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool isNAPowerOfK(int n, int k); 6 | 7 | int main() 8 | { 9 | int n = 0, k = 0; 10 | cin >> n >> k; 11 | cout << isNAPowerOfK(n, k) << endl; 12 | return 0; 13 | } 14 | 15 | bool isNAPowerOfK(int n, int k) 16 | { 17 | if (n < k) { 18 | if (n == 1) { 19 | return true; 20 | } else { 21 | return false; 22 | } 23 | } else if (n == k) { 24 | return true; 25 | } else if (k == 1) { 26 | return false; 27 | } else { 28 | int product = k; 29 | while (product < n) { 30 | product *= product; 31 | } 32 | if (product == n) { 33 | return true; 34 | } else { 35 | while (product > n) { 36 | product /= k; 37 | } 38 | if (product == n) { 39 | return true; 40 | } 41 | } 42 | return false; 43 | } 44 | } -------------------------------------------------------------------------------- /code-set/11.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | 7 | public class Main { 8 | public static void main(String arg[]) { 9 | Scanner snc = new Scanner(System.in); 10 | int n = snc.nextInt(); 11 | int k = snc.nextInt(); 12 | Main main = new Main(); 13 | System.out.println(main.isNAPowerOfK(n, k)); 14 | } 15 | 16 | public int isNAPowerOfK(int n, int k) { 17 | if (n < k) { 18 | if (n == 1) { 19 | return 1; 20 | } else { 21 | return 0; 22 | } 23 | } else if (n == k) { 24 | return 1; 25 | } else if (k == 1) { 26 | return 0; 27 | } else { 28 | for (int iter = k; iter <= n; iter *= k) { 29 | if (iter < n) { 30 | continue; 31 | } else { 32 | return 1; 33 | } 34 | } 35 | return 0; 36 | } 37 | } 38 | } 39 | 40 | 41 | // 42 | // _oo0oo_ 43 | // o8888888o 44 | // 88" . "88 45 | // (| -_- |) 46 | // 0\ = /0 47 | // ___/`---'\___ 48 | // .' \\| |// '. 49 | // / \\||| : |||// \ 50 | // / _||||| -:- |||||- \ 51 | // | | \\\ - /// | | 52 | // | \_| ''\---/'' |_/ | 53 | // \ .-\__ '-' ___/-. / 54 | // ___'. .' /--.--\ `. .'___ 55 | // ."" '< `.___\_<|>_/___.' >' "". 56 | // | | : `- \`.;`\ _ /`;.`/ - ` : | | 57 | // \ \ `_. \_ __\ /__ _/ .-` / / 58 | // =====`-.____`.___ \_____/___.-`___.-'===== 59 | // `=---=' 60 | // 61 | // 62 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 63 | // 64 | // 佛祖保佑 永无BUG 65 | // -------------------------------------------------------------------------------- /code-set/12.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | public static void main(String[] args) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | System.out.println(Hibonacci(n)); 11 | } 12 | 13 | public static int Hibonacci(int n) { 14 | int H0 = 0, H1 = 1, H2 = 1; 15 | for (int iter = 0; iter < n / 3; iter++) { 16 | int temp0 = H0 + H1 + H2; 17 | int temp1 = temp0 + H1 + H2; 18 | int temp2 = temp0 + temp1 + H2; 19 | H0 = temp0; 20 | H1 = temp1; 21 | H2 = temp2; 22 | } 23 | switch (n % 3) { 24 | case 0: 25 | return H0; 26 | case 1: 27 | return H1; 28 | case 2: 29 | return H2; 30 | default: 31 | return -1; 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /code-set/13.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | 5 | public static void main(String arg[]) { 6 | Scanner snc = new Scanner(System.in); 7 | int n = snc.nextInt(); 8 | 9 | Main main = new Main(); 10 | System.out.println(main.addSumOfN(n)); 11 | } 12 | 13 | public int addSumOfN(int n) { 14 | return (1 + n) * n / 2; 15 | } 16 | } -------------------------------------------------------------------------------- /code-set/14.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | class Main { 7 | public static int backOne(int n) { 8 | if (n == 1) { 9 | return 0; 10 | } else { 11 | if (n % 2 == 0) { 12 | return backOne(n / 2) + 1; 13 | } else { 14 | int biggerOne = backOne(n + 1) + 1; 15 | int smallerOne = backOne(n - 1) + 1; 16 | if (biggerOne > smallerOne) { 17 | return smallerOne; 18 | } else { 19 | return biggerOne; 20 | } 21 | } 22 | } 23 | } 24 | 25 | public static void main(String[] args) { 26 | Scanner scanner = new Scanner(System.in); 27 | int n = scanner.nextInt(); 28 | System.out.println(backOne(n)); 29 | } 30 | } -------------------------------------------------------------------------------- /code-set/15.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | import java.util.Stack; 3 | 4 | /** 5 | * OJ 6 | * 7 | * @author ysxiang 8 | */ 9 | class Main { 10 | public static void main(String[] args) { 11 | Scanner scanner = new Scanner(System.in); 12 | String str = scanner.nextLine(); 13 | System.out.println(new Main().calculateResult(str.toCharArray())); 14 | } 15 | 16 | /** 17 | * Calculate the result. 18 | * @param chars 19 | */ 20 | public char calculateResult(char[] chars) { 21 | Stack stack = new Stack<>(); 22 | int charsLength = chars.length; 23 | for (int iter = charsLength - 1; iter >= 0; iter--) { 24 | if (chars[iter] == ':') { 25 | stack.push(chars[--iter]); 26 | } else if (chars[iter] == '?') { 27 | char temp = stack.pop(); 28 | if (chars[--iter] == 'T') { 29 | stack.pop(); 30 | stack.push(temp); 31 | } 32 | } else { 33 | stack.push(chars[iter]); 34 | } 35 | } 36 | return stack.peek(); 37 | } 38 | } -------------------------------------------------------------------------------- /code-set/16.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @author ysxiang 3 | */ 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | int effectiveSub(std::vector& nums); 10 | void solution16(); 11 | int lowbit(int x); 12 | void add(int x, int v, int n); 13 | int query(int x); 14 | 15 | static constexpr int MOD = 1000000007; 16 | static vector tree(200010); 17 | 18 | void solution16() 19 | { 20 | int temp; 21 | vector chars; 22 | while (cin >> temp) { 23 | chars.push_back(temp); 24 | } 25 | std::cout << effectiveSub(chars) << std::endl; 26 | return; 27 | } 28 | 29 | int lowbit(int x) 30 | { 31 | return x & -x; 32 | } 33 | 34 | int query(int x) 35 | { 36 | int ans = 0; 37 | for (int iter = x; iter > 0; iter -= lowbit(iter)) { 38 | ans += tree[iter]; 39 | } 40 | return ans; 41 | } 42 | 43 | void add(int x, int v, int n) 44 | { 45 | for (int iter = x; iter <= 2 * n + 1; iter += lowbit(iter)) { 46 | tree[iter] += v; 47 | } 48 | } 49 | 50 | int effectiveSub(std::vector& nums) 51 | { 52 | int nums_length = nums.size(); 53 | vector sum(nums_length + 1); 54 | int sub_count = 0; 55 | for (int iter = 1; iter <= nums_length; iter++) { 56 | sum[iter] = sum[iter - 1] + ((nums[iter - 1] == 0) ? -1 : 1); // 将nums数组的[0, 1]映射到[-1, 1],并累加 57 | } 58 | for (int iter = 0; iter <= nums_length; iter++) { 59 | int temp = sum[iter] + nums_length + 1; // [-n, n] -> [1, 2n + 1] 60 | sub_count = (sub_count + query(temp - 1)) % MOD; 61 | add(temp, 1, nums_length); 62 | } 63 | 64 | return sub_count; 65 | } 66 | 67 | int main() 68 | { 69 | solution16(); 70 | } -------------------------------------------------------------------------------- /code-set/17.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Scanner; 3 | 4 | /** 5 | * @author ysxiang 6 | */ 7 | class Main { 8 | 9 | public int getSteps( 10 | ArrayList nums, 11 | int currentSum, int targetSum, 12 | int frontFlag, int backFlag 13 | ) { 14 | if (currentSum > targetSum) { 15 | return -1; 16 | } else if (currentSum == targetSum) { 17 | return 1; 18 | } else { 19 | if (frontFlag < backFlag) { 20 | int front2back = getSteps( // 从前往后 21 | nums, 22 | currentSum + nums.get(frontFlag), targetSum, 23 | frontFlag + 1, backFlag 24 | ); 25 | int back2front = getSteps( // 从后往前 26 | nums, 27 | currentSum + nums.get(backFlag - 1), targetSum, 28 | frontFlag, backFlag - 1 29 | ); 30 | if (front2back == -1 && back2front == -1) { 31 | return -1; 32 | } else if (front2back == -1) { 33 | return back2front + 1; 34 | } else if (back2front == -1) { 35 | return front2back + 1; 36 | } else { 37 | if (back2front > front2back) { 38 | return front2back + 1; 39 | } else { 40 | return back2front + 1; 41 | } 42 | } 43 | } else { 44 | return -1; 45 | } 46 | } 47 | } 48 | 49 | public int minSelect(int targetSum, ArrayList nums) { 50 | if (nums.size() >= 2) { 51 | int front2back = getSteps( // 从前往后 52 | nums, 53 | nums.get(0), targetSum, 54 | 1, nums.size()); 55 | int back2front = getSteps( // 从后往前 56 | nums, 57 | nums.get(nums.size() - 1), targetSum, 58 | 0, nums.size() - 1 59 | ); 60 | if (front2back == -1 && back2front == -1) { 61 | return -1; 62 | } else if (front2back == -1) { 63 | return back2front; 64 | } else if (back2front == -1) { 65 | return front2back; 66 | } else { 67 | if (back2front > front2back) { 68 | return front2back; 69 | } else { 70 | return back2front; 71 | } 72 | } 73 | } else if (nums.size() == 1) { 74 | if (nums.get(0) == targetSum) { 75 | return 1; 76 | } 77 | } 78 | return -1; 79 | } 80 | 81 | public static void main(String[] args) { 82 | Scanner scanner = new Scanner(System.in); 83 | int targetSum = scanner.nextInt(); 84 | String numStr = ""; 85 | ArrayList nums = new ArrayList(); 86 | while ((numStr = scanner.next()).equals("q") == false) { 87 | nums.add(Integer.parseInt(numStr)); 88 | } 89 | System.out.println(new Main().minSelect(targetSum, nums)); 90 | } 91 | } -------------------------------------------------------------------------------- /code-set/18.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | import java.util.Stack; 3 | 4 | /** 5 | * OJ 6 | * 7 | * @author ysxiang 8 | */ 9 | class Main { 10 | public static void main(String[] args) { 11 | Scanner scanner = new Scanner(System.in); 12 | String str = scanner.nextLine(); 13 | System.out.println(new Main().trueOrFalse(str.toCharArray())); 14 | } 15 | 16 | /** 17 | * judge expression is true or false. 18 | * 19 | * @param chars 字符数组 20 | */ 21 | public int trueOrFalse(char[] chars) { 22 | Stack numbers = new Stack<>(); 23 | Stack operations = new Stack<>(); 24 | for (char charIter : chars) { 25 | switch (charIter) { 26 | case '|': 27 | case '&': 28 | case '!': 29 | operations.push(charIter); 30 | break; 31 | case 't': 32 | case 'f': 33 | case '(': 34 | numbers.push(charIter); 35 | break; 36 | case ')': 37 | boolean tempFlag = false; 38 | char number; 39 | switch (operations.pop()) { 40 | case '|': 41 | tempFlag = false; 42 | while ((number = numbers.pop()) != '(') { 43 | tempFlag |= (number == 't'); 44 | } 45 | numbers.push(tempFlag ? 't' : 'f'); 46 | break; 47 | case '&': 48 | tempFlag = true; 49 | while ((number = numbers.pop()) != '(') { 50 | tempFlag &= (number == 't'); 51 | } 52 | numbers.push(tempFlag ? 't' : 'f'); 53 | break; 54 | case '!': 55 | while ((number = numbers.pop()) != '(') { 56 | tempFlag = (number != 't'); 57 | } 58 | numbers.push(tempFlag ? 't' : 'f'); 59 | break; 60 | } 61 | default: 62 | break; 63 | } 64 | } 65 | 66 | if (numbers.pop() == 't') { 67 | return 1; 68 | } else { 69 | return 0; 70 | } 71 | } 72 | } -------------------------------------------------------------------------------- /code-set/19.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Scanner; 3 | 4 | /** 5 | * @author ysxiang 6 | */ 7 | class Main { 8 | public ArrayList rightBigger(ArrayList nums) { 9 | ArrayList targetNums = new ArrayList(); 10 | for (int iter = 0; iter < nums.size(); iter++) { 11 | int iterNum = nums.get(iter); 12 | int count = 0; 13 | for (int j = iter + 1; j < nums.size(); j++) { 14 | if (iterNum > nums.get(j)) { 15 | count++; 16 | } 17 | } 18 | targetNums.add(count); 19 | } 20 | 21 | return targetNums; 22 | } 23 | 24 | public static void main(String[] args) { 25 | Scanner scanner = new Scanner(System.in); 26 | String numStr = ""; 27 | ArrayList nums = new ArrayList(); 28 | while ((numStr = scanner.next()).equals("q") == false) { 29 | nums.add(Integer.parseInt(numStr)); 30 | } 31 | ArrayList targetNums = new Main().rightBigger(nums); 32 | for (int iter = 0; iter < targetNums.size() - 1; iter++) { 33 | System.out.print(targetNums.get(iter) + " "); 34 | } 35 | System.out.println(targetNums.get(targetNums.size() - 1)); 36 | } 37 | } -------------------------------------------------------------------------------- /code-set/20.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | class Main { 7 | public final static int N_MAX = 2_000_000_000; 8 | public final static String[] singles = {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}; 9 | public final static String[] teens = {"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"}; 10 | public final static String[] tens = {"Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"}; 11 | public final static String[] thousands = {"", "Thousand", "Million", "Billion"}; 12 | 13 | public void recursion(StringBuffer currentStr, int num) { 14 | if (num == 0) { 15 | return; 16 | } else if (num < 10) { 17 | currentStr.append(singles[num - 1]).append(" "); 18 | } else if (num < 20) { 19 | currentStr.append(teens[num - 10]).append(" "); 20 | } else if (num < 100) { 21 | currentStr.append(tens[num / 10 - 1]).append(" "); 22 | recursion(currentStr, num % 10); 23 | } else { 24 | currentStr.append(singles[num / 100 - 1]).append(" Hundred "); 25 | recursion(currentStr, num % 100); 26 | } 27 | } 28 | 29 | 30 | public String translateNumber (int num) { 31 | if(num == 0) { 32 | return "Zero"; 33 | } 34 | StringBuffer sb = new StringBuffer(); 35 | for (int i = 3, unit = 1_000_000_000; i >= 0; i--, unit /= 1000) { 36 | int currentNum = num / unit; 37 | if (currentNum != 0) { 38 | num -= currentNum * unit; 39 | StringBuffer currentStr = new StringBuffer(); 40 | recursion(currentStr, currentNum); 41 | currentStr.append(thousands[i]).append(" "); 42 | sb.append(currentStr); 43 | } 44 | } 45 | return sb.toString().trim(); 46 | } 47 | 48 | public static void main(String[] args) { 49 | Scanner scanner = new Scanner(System.in); 50 | int num = scanner.nextInt(); 51 | System.out.println(new Main().translateNumber(num)); 52 | } 53 | } -------------------------------------------------------------------------------- /code-set/21.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * OJ 5 | * Dynamic Programming 6 | * 7 | * @author ysxiang 8 | */ 9 | class Main { 10 | public static void main(String[] args) { 11 | Scanner sn = new Scanner(System.in); 12 | int inputValue = sn.nextInt(); 13 | System.out.println(new Main().lastRemaining(inputValue)); 14 | } 15 | 16 | /** 17 | * @param n 数组长度 18 | * @param fromLeft ture 从左到右，false从右到左 19 | * @return 20 | */ 21 | public int recursion(int n, boolean fromLeft) { 22 | if (n == 1) { 23 | return 1; 24 | } 25 | if (fromLeft) { 26 | return 2 * recursion(n / 2, false); // 剩下的都是双数 27 | } else { 28 | if (n % 2 == 1) { 29 | return 2 * recursion(n / 2, true); 30 | } else { 31 | return 2 * recursion(n / 2, true) - 1; 32 | } 33 | } 34 | } 35 | 36 | public int lastRemaining(int n) { 37 | return recursion(n, true); // 先从左到右 38 | } 39 | } -------------------------------------------------------------------------------- /code-set/22.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main { 7 | public static void main(String[] args) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | System.out.println(getFibonacci(n)); 11 | } 12 | 13 | public static int getFibonacci(int n) { 14 | int H0 = 0, H1 = 1; 15 | for (int iter = 0; iter < n / 2; iter++) { 16 | int temp0 = H0 + H1; 17 | int temp1 = temp0 + H1; 18 | H0 = temp0; 19 | H1 = temp1; 20 | } 21 | switch (n % 2) { 22 | case 0: 23 | return H0; 24 | case 1: 25 | return H1; 26 | default: 27 | return -1; 28 | } 29 | } 30 | } -------------------------------------------------------------------------------- /code-set/24.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | // 二叉搜索树 6 | int index = 0; 7 | int arr[2000]; 8 | bool is_end = false; 9 | 10 | bool judgeBST(int start, int end) 11 | { 12 | if (start >= end) { 13 | return true; 14 | } 15 | int middle = end; 16 | for (int iter = start; iter < end; iter++) { 17 | if (arr[iter] > arr[end]) { 18 | middle = iter; 19 | break; 20 | } 21 | } 22 | if (middle == end) { 23 | return judgeBST(start, end - 1); 24 | } 25 | for (int iter = middle; iter < end; iter++) { 26 | if (arr[iter] < arr[end]) { 27 | return false; 28 | } 29 | } 30 | if (start == middle) { 31 | return judgeBST(middle, end - 1); 32 | } 33 | return judgeBST(start, middle - 1) && judgeBST(middle, end - 1); 34 | } 35 | 36 | int read() 37 | { 38 | char ch = getchar(); 39 | while (ch < '0' || ch > '9') { 40 | ch = getchar(); 41 | } 42 | int number = 0; 43 | while (ch >= '0' && ch <= '9') { 44 | number = number * 10 + ch - '0'; 45 | ch = getchar(); 46 | } 47 | if (ch == ']') { 48 | is_end = true; 49 | } 50 | return number; 51 | } 52 | 53 | void solution24() 54 | { 55 | while (!is_end) { 56 | arr[index++] = read(); 57 | } 58 | if (judgeBST(0, index - 1)) { 59 | cout << "true" << endl; 60 | } else { 61 | cout << "false" << endl; 62 | } 63 | } 64 | 65 | int main() 66 | { 67 | solution24(); 68 | return 0; 69 | } -------------------------------------------------------------------------------- /code-set/25.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main{ 7 | private final static int N = 1_000_000_007; 8 | 9 | public static void main(String[] args) { 10 | Scanner scanner = new Scanner(System.in); 11 | int n = scanner.nextInt(); 12 | System.out.println(new Main().getGoodDivisor(n)); 13 | } 14 | 15 | /** 16 | * solution. 17 | */ 18 | public int getGoodDivisor(int n) { 19 | 20 | if (n <= 3) { 21 | return n; 22 | } 23 | int a = n / 3, b = n % 3; 24 | if (b == 1) { 25 | return (int) (quickPow(3, a - 1, N) * 4 % N); 26 | } else if (b == 2) { 27 | return (int) (quickPow(3, a, N) * 2 % N); 28 | } else { 29 | return (int) quickPow(3, a, N); 30 | } 31 | } 32 | 33 | 34 | /** 35 | * 快速求幂： 36 | * p^q，计算中防止溢出，对MOD求余 37 | */ 38 | public long quickPow(int p, int q, int MOD) { 39 | long ans = 1L; 40 | long base = p; 41 | while (q != 0) { 42 | if (q % 2 == 1) { 43 | ans = ans * base % MOD; 44 | } 45 | base = base * base % MOD; 46 | q = q / 2; 47 | } 48 | return ans; 49 | } 50 | } -------------------------------------------------------------------------------- /code-set/26.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | * 阶乘 9 | */ 10 | int factorial(int n) 11 | { 12 | if (n == 0) { 13 | return 1; 14 | } 15 | int res = 1; 16 | for (int iter = 2; iter < n + 1; iter++) { 17 | res *= iter; 18 | } 19 | return res; 20 | } 21 | 22 | void get_permutation(int n, int k) 23 | { 24 | vector nums; 25 | vector num_list; 26 | for (int iter = 0; iter < n; iter++) { 27 | num_list.push_back(iter + 1); 28 | int tmp = factorial(n - iter - 1); 29 | int index = ceil((double)k / (double)tmp) - 1; 30 | if (index > 0) { 31 | nums.push_back(index); 32 | } else { 33 | nums.push_back(0); 34 | } 35 | k %= tmp; 36 | if (k == 0) { 37 | k = tmp; 38 | } 39 | } 40 | for (int iter : nums) { 41 | cout << num_list[iter]; 42 | num_list.erase(num_list.begin() + iter); 43 | } 44 | cout << endl; 45 | } 46 | 47 | void solution26() 48 | { 49 | int n; 50 | int k; 51 | cin >> n >> k; 52 | get_permutation(n, k); 53 | } 54 | 55 | int main() 56 | { 57 | solution26(); 58 | return 0; 59 | } -------------------------------------------------------------------------------- /code-set/27.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * OJ 5 | * 6 | * @author ysxiang 7 | */ 8 | public class Main { 9 | public final static long MOD = 1_000_000_007; 10 | 11 | public int minNonZeroProduct(int index) { 12 | long a = (1L << index) - 1L; 13 | long b = a - 1L; 14 | long c = b / 2L; 15 | return (int) ((a % MOD) * (quickPow(b % MOD, c)) % MOD); 16 | } 17 | 18 | /** 19 | * 快速幂 20 | * 21 | * @param a 22 | * @param index 23 | * @return 24 | */ 25 | public long quickPow(long a, long index) { 26 | long base = a; 27 | long ans = 1L; 28 | while (index > 0) { 29 | if ((index & 1L) == 1L) { 30 | ans = (ans * base) % MOD; 31 | } 32 | base = (base * base) % MOD; 33 | index >>= 1; 34 | } 35 | return ans; 36 | } 37 | 38 | public static void main(String[] args) { 39 | Scanner scanner = new Scanner(System.in); 40 | int p = scanner.nextInt(); 41 | System.out.println(new Main().minNonZeroProduct(p)); 42 | } 43 | } -------------------------------------------------------------------------------- /code-set/28.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | public class Main{ 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | int n = scanner.nextInt(); 10 | int k = scanner.nextInt(); 11 | System.out.print(new Main().getResult(n, k)); 12 | } 13 | 14 | /** 15 | * 递归 16 | * @param n 17 | * @param k 18 | * @return 19 | */ 20 | public int getResult(int n, int k) { 21 | if (n == 1 && k == 1) { 22 | return 0; 23 | } 24 | int middle = 1 << (n - 1); // 2 ^ (n - 1) 25 | if (k == middle) { 26 | return 1; 27 | } else if (k < middle) { 28 | return getResult(n - 1, k); 29 | } else { 30 | k = (middle << 1) - k; 31 | return invert(getResult(n - 1, k)); 32 | } 33 | } 34 | 35 | public int invert(int var) { 36 | return 1 - var; 37 | } 38 | } -------------------------------------------------------------------------------- /code-set/29.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void task29() 6 | { 7 | int num; 8 | std::cin >> num; 9 | int *nums = new int[11]; 10 | for (int iter = 0; iter < num; iter++) 11 | { 12 | nums[iter] = iter + 1; 13 | } 14 | do { 15 | for (int iter = 0; iter < num; iter++) 16 | { 17 | std::cout << nums[iter]; 18 | } 19 | std::cout << std::endl; 20 | } while (std::next_permutation(nums, nums + num)); 21 | return; 22 | } 23 | 24 | 25 | int main() 26 | { 27 | task29(); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /code-set/30.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | Scanner scanner = new Scanner(System.in); 6 | int n = scanner.nextInt(); 7 | System.out.print(new Main().getResult(n)); 8 | } 9 | 10 | public String getResult(int n) { 11 | if (n == 1) { 12 | return "1"; 13 | } else if (n == 2) { 14 | return "11"; 15 | } 16 | String str = String.valueOf(11); 17 | int prefix = 0, suffix = 0; 18 | int count = 1; 19 | for (int iter = 2; iter < n; iter++) { 20 | String tempStr = ""; 21 | for (int index = 1; index < str.length(); index++) { 22 | prefix = Integer.parseInt(str.substring(index - 1, index)); 23 | suffix = Integer.parseInt(str.substring(index, index + 1)); 24 | if (prefix == suffix) { 25 | count++; 26 | } else { 27 | tempStr += String.valueOf(count) + String.valueOf(prefix); 28 | count = 1; 29 | } 30 | } 31 | prefix = Integer.parseInt(str.substring(str.length() - 1, str.length())); 32 | tempStr += String.valueOf(count) + String.valueOf(prefix); 33 | str = tempStr; 34 | count = 1; 35 | } 36 | return str; 37 | } 38 | } -------------------------------------------------------------------------------- /code-set/33.java: -------------------------------------------------------------------------------- 1 | import java.math.BigInteger; 2 | import java.util.Scanner; 3 | 4 | 5 | /** 6 | * @author ysxiang 7 | */ 8 | 9 | class Main { 10 | public final int MOD = 1337; 11 | 12 | /** 13 | * calculate (a ^ b) mod MOD 14 | * @param a 15 | * @param b 16 | * @return 17 | */ 18 | public long bigPow(int a, String b) { 19 | long ans = 1L; 20 | long base = a; 21 | BigInteger big = new BigInteger(String.valueOf(b)); 22 | while (!big.equals(new BigInteger(String.valueOf(0)))) { 23 | if (big.mod(new BigInteger(String.valueOf(2))).equals(new BigInteger(String.valueOf(1)))) { 24 | ans = ans * base % MOD; 25 | } 26 | base = base * base % MOD; 27 | big = big.divide(new BigInteger(String.valueOf(2))); 28 | } 29 | return ans; 30 | } 31 | 32 | public static void main(String[] args) { 33 | Scanner sc = new Scanner(System.in); 34 | int a = sc.nextInt(); 35 | int n = sc.nextInt(); 36 | StringBuffer b = new StringBuffer(); 37 | for (int i = 0; i < n; i++) { 38 | b.append(sc.next()); 39 | } 40 | System.out.println(new Main().bigPow(a, b.toString())); 41 | } 42 | } -------------------------------------------------------------------------------- /code-set/34.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | class Main { 7 | 8 | public int specialSection(int[] nums, int lower, int upper) { 9 | int numsLength = nums.length; 10 | int sectionNumber = 0; // 符合要求区间的个数 11 | int sectionSum = 0; // 区间内的数字和 12 | for (int i = 0; i < numsLength; i++) { 13 | for (int j = i; j < numsLength; j++) { 14 | sectionSum += nums[j]; 15 | if (sectionSum >= lower && sectionSum <= upper) { 16 | sectionNumber++; 17 | } 18 | } 19 | sectionSum = 0; 20 | } 21 | return sectionNumber; 22 | } 23 | 24 | public static void main(String[] args) { 25 | Scanner scanner = new Scanner(System.in); 26 | String str = scanner.nextLine(); 27 | String arr[] = str.split(" "); 28 | int[] nums = new int[arr.length]; 29 | for (int iter = 0; iter < nums.length; iter++) { 30 | nums[iter] = Integer.parseInt(arr[iter]); 31 | } 32 | int lower = scanner.nextInt(); 33 | int upper = scanner.nextInt(); 34 | System.out.println(new Main().specialSection(nums, lower, upper)); 35 | } 36 | } -------------------------------------------------------------------------------- /code-set/35.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | class Main { 7 | 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | int n = scanner.nextInt(); 11 | 12 | System.out.println(new Main().isPowerOfFour(n)); 13 | } 14 | 15 | public boolean isPowerOfFour(int number) { 16 | if (number == 1) { 17 | return true; 18 | } 19 | int result = 4; 20 | for (; result < number; result *= 4) { 21 | 22 | } 23 | if (result == number) { 24 | return true; 25 | } 26 | return false; 27 | } 28 | } -------------------------------------------------------------------------------- /code-set/37.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int cost[50][50]; 7 | int dp[50][50]; 8 | 9 | int min_cost(int m) 10 | { 11 | for (int iter = 0; iter < m; iter++) { 12 | for (int jter = 0; jter < m; jter++) { 13 | if (iter == 0 && jter == 0) { 14 | dp[0][0] = cost[0][0]; 15 | } else if (iter == 0 && jter > 0) { 16 | dp[0][jter] = dp[0][jter - 1] + cost[0][jter]; 17 | } else if (iter > 0 && jter == 0) { 18 | dp[iter][0] = dp[iter - 1][0] + cost[iter][0]; 19 | } else { 20 | dp[iter][jter] = min( 21 | dp[iter - 1][jter] + cost[iter][jter], 22 | dp[iter][jter - 1] + cost[iter][jter]); 23 | } 24 | } 25 | } 26 | return dp[m - 1][m - 1]; 27 | } 28 | 29 | void solution37() 30 | { 31 | int m; 32 | cin >> m; 33 | for (int iter = 0; iter < m; iter++) { 34 | for (int jter = 0; jter < m; jter++) { 35 | cin >> cost[iter][jter]; 36 | } 37 | } 38 | cout << min_cost(m) << endl; 39 | } 40 | 41 | int main() 42 | { 43 | solution37(); 44 | return 0; 45 | } -------------------------------------------------------------------------------- /code-set/41.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * @author ysxiang 5 | */ 6 | import java.util.Scanner; 7 | 8 | class Main { 9 | public int rob(int[] nums) { 10 | int numsLength = nums.length; 11 | int[] maxMoney = new int[100]; 12 | maxMoney[0] = nums[0]; 13 | maxMoney[1] = nums[1]; 14 | maxMoney[2] = maxMoney[0] + nums[2]; 15 | for (int iter = 3; iter < numsLength; iter++) { 16 | maxMoney[iter] = nums[iter] + Math.max(maxMoney[iter - 2], maxMoney[iter - 3]); 17 | } 18 | return (Math.max(maxMoney[numsLength - 1], maxMoney[numsLength - 2])); 19 | } 20 | 21 | public static void main(String[] args) { 22 | Scanner scanner = new Scanner(System.in); 23 | int n = scanner.nextInt(); 24 | int[] ans = new int[n]; 25 | for (int i = 0; i < n; i++) { 26 | ans[i] = scanner.nextInt(); 27 | } 28 | System.out.println(new Main().rob(ans)); 29 | } 30 | } -------------------------------------------------------------------------------- /code-set/43.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int nums[200]; 6 | int dp[201]; 7 | 8 | // Dynamic Programming 9 | int combination_sum(int nums_length, int target) 10 | { 11 | dp[0] = 1; 12 | for (int iter = 1; iter <= target; iter++) { 13 | for (int index = 0; index < nums_length; index++) { 14 | int num = nums[index]; 15 | if (iter >= num) { 16 | dp[iter] += dp[iter - num]; 17 | } 18 | } 19 | } 20 | return dp[target]; 21 | } 22 | 23 | void solution43() 24 | { 25 | int num, target; 26 | cin >> num; 27 | for (int iter = 0; iter < num; iter++) { 28 | cin >> nums[iter]; 29 | } 30 | cin >> target; 31 | cout << combination_sum(num, target) << endl; 32 | } 33 | 34 | int main() 35 | { 36 | solution43(); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /code-set/44.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int max_profit(vector& prices) 9 | { 10 | int prices_length = prices.size(); 11 | vector profits(prices_length); 12 | for (int i = 1; i < prices_length; i++) { 13 | profits[i] = prices[i] - prices[i - 1]; 14 | } 15 | vector> dp(prices_length + 1, vector(2)); 16 | for (int i = 1; i < prices_length; i++) { 17 | dp[i][0] = max(profits[i], dp[i - 1][0] + profits[i]); 18 | } 19 | for (int i = 1; i < prices_length; i++) { 20 | dp[i][0] = max(dp[i - 1][0], dp[i][0]); 21 | } 22 | for (int i = prices_length - 1; i >= 0; i--) { 23 | dp[i][1] = max(profits[i], dp[i + 1][1] + profits[i]); 24 | } 25 | for (int i = prices_length - 1; i >= 0; i--) { 26 | dp[i][1] = max(dp[i][1], dp[i + 1][1]); 27 | } 28 | int result = 0; 29 | for (int i = 0; i < prices_length; i++) { 30 | result = max(result, dp[i][0] + dp[i + 1][1]); 31 | } 32 | return result; 33 | } 34 | 35 | void solution44() 36 | { 37 | int nums_length; 38 | cin >> nums_length; 39 | vector nums(nums_length); 40 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 41 | cin >> *iter; 42 | } 43 | cout << max_profit(nums) << endl; 44 | } 45 | 46 | int main() 47 | { 48 | solution44(); 49 | return 0; 50 | } -------------------------------------------------------------------------------- /code-set/45.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | /** 4 | * OJ 5 | * Dynamic Programming 6 | * @author ysxiang 7 | */ 8 | class Main { 9 | public static int longestSubsequence(int[] arr, int difference) { 10 | int arrLength = arr.length; 11 | int[] dp = new int[arrLength]; 12 | int maxLength = 0; 13 | for (int i = 0; i < arrLength; i++) { 14 | for (int j = 0; j < i; j++) { 15 | if (arr[i] - arr[j] == difference) { 16 | dp[i] = dp[j] + 1; 17 | maxLength = Math.max(maxLength, dp[i]); 18 | } 19 | } 20 | } 21 | return maxLength + 1; 22 | } 23 | 24 | public static void main(String[] args) { 25 | Scanner scanner = new Scanner(System.in); 26 | int n = scanner.nextInt(); 27 | int[] arr = new int[n]; 28 | for (int i = 0; i < n; i++) { 29 | arr[i] = scanner.nextInt(); 30 | } 31 | int difference = scanner.nextInt(); 32 | System.out.println(longestSubsequence(arr,difference)); 33 | } 34 | } -------------------------------------------------------------------------------- /code-set/46.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int nums[100]; 6 | 7 | bool canPartition(int nums_length) 8 | { 9 | int sum = 0; 10 | for (int iter = 0; iter < nums_length; iter++) { 11 | sum += nums[iter]; 12 | } 13 | if ((sum & 1) != 0) { // 若sum为单数 14 | return false; 15 | } 16 | int target = sum >> 1; 17 | bool* dp = new bool[target + 1]; 18 | dp[0] = true; 19 | for (int iter = 0; iter < nums_length; iter++) { 20 | int num = nums[iter]; 21 | if (num > target) { 22 | return false; 23 | } 24 | dp[num] = true; 25 | for (int jter = 0; jter <= target - num; jter++) { 26 | dp[jter + num] = dp[jter] || dp[num]; 27 | } 28 | } 29 | return dp[target]; 30 | } 31 | 32 | void solution46() 33 | { 34 | int nums_length; 35 | cin >> nums_length; 36 | for (int iter = 0; iter < nums_length; iter++) { 37 | cin >> nums[iter]; 38 | } 39 | cout << (canPartition(nums_length) ? "true" : "false") << endl; 40 | } 41 | 42 | int main() 43 | { 44 | solution46(); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /code-set/47.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int coins[12]; 7 | 8 | int coinChange(int coins_length, int amount) 9 | { 10 | for (int iter = coins_length - 1; iter >= 0; iter--) { 11 | int coin = coins[iter]; 12 | if (coin > amount) { 13 | continue; 14 | } else if (coin == amount) { 15 | return 1; 16 | } else { 17 | return coinChange(coins_length, amount - coin) + 1; 18 | } 19 | } 20 | cout << -1 << endl; 21 | exit(0); 22 | } 23 | 24 | void solution47() 25 | { 26 | int coins_length, amount; // 宝石个数，总价格 27 | cin >> coins_length; 28 | for (int index = 0; index < coins_length; index++) { 29 | cin >> coins[index]; 30 | } 31 | cin >> amount; 32 | sort(coins, coins + coins_length); 33 | cout << coinChange(coins_length, amount) << endl; 34 | } 35 | 36 | int main() 37 | { 38 | solution47(); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /code-set/48.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int nums[200]; 7 | 8 | int maxProduct(int nums_length) 9 | { 10 | int max_product = 1; 11 | int min_product = 1; 12 | int max_value = 0; 13 | for (int iter = 0; iter < nums_length; iter++) { 14 | if (nums[iter] < 0) { 15 | int temp = max_product; 16 | max_product = min_product; 17 | min_product = temp; 18 | } 19 | max_product = max(max_product * nums[iter], nums[iter]); 20 | min_product = min(min_product * nums[iter], nums[iter]); 21 | max_value = max(max_product, max_value); 22 | } 23 | return max_value; 24 | } 25 | 26 | void solution48() 27 | { 28 | int nums_length; 29 | cin >> nums_length; 30 | for (int iter = 0; iter < nums_length; iter++) { 31 | cin >> nums[iter]; 32 | } 33 | cout << maxProduct(nums_length) << endl; 34 | } 35 | 36 | int main() 37 | { 38 | solution48(); 39 | } -------------------------------------------------------------------------------- /code-set/50.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | input: 3 | abcde 4 | ace 5 | 6 | 注意！罗扣上输入样例应该是不包含双引号的！ 7 | 所有的输入也是不包含双引号的！ 8 | */ 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | int dp[101][101]; 17 | 18 | // 返回最长公共子序列的个数 19 | // Dynamic Programming 20 | int longest_common_subsequence(string& text1, string& text2) 21 | { 22 | int text1_length = text1.length(); 23 | int text2_length = text2.length(); 24 | for (int iter = 1; iter <= text1_length; iter++) { 25 | for (int jter = 1; jter <= text2_length; jter++) { 26 | if (text1[iter - 1] == text2[jter - 1]) { 27 | dp[iter][jter] = dp[iter - 1][jter - 1] + 1; 28 | } else { 29 | dp[iter][jter] = max( 30 | dp[iter][jter - 1], 31 | dp[iter - 1][jter]); 32 | } 33 | } 34 | } 35 | return dp[text1_length][text2_length]; 36 | } 37 | 38 | void solution50() 39 | { 40 | string text1; 41 | string text2; 42 | cin >> text1 >> text2; 43 | cout << longest_common_subsequence(text1, text2) << endl; 44 | } 45 | 46 | int main() 47 | { 48 | solution50(); 49 | return 0; 50 | } -------------------------------------------------------------------------------- /code-set/51.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | // 背包问题 8 | // 一个矿只能采一次 9 | int maxValue(vector& costs, vector& values, int total_time) 10 | { 11 | int variety_number = costs.size(); // 矿物数量 12 | vector> dp(variety_number + 1, vector(total_time + 1)); 13 | for (int iter = 1; iter <= variety_number; iter++) { 14 | for (int jter = 1; jter <= total_time; jter++) { 15 | if (jter >= costs[iter]) { // 替换出背包里的物品 16 | dp[iter][jter] = max( 17 | dp[iter - 1][jter - costs[iter]] + values[iter], 18 | dp[iter - 1][jter]); 19 | } else { // 按照背包原来的物品 20 | dp[iter][jter] = dp[iter - 1][jter]; 21 | } 22 | } 23 | } 24 | return dp[variety_number][total_time]; 25 | } 26 | 27 | void solution51() 28 | { 29 | int total_time, variety_number; 30 | int cost, value; 31 | 32 | cin >> total_time >> variety_number; 33 | vector costs(variety_number + 1); 34 | vector values(variety_number + 1); 35 | for (int index = 1; index <= variety_number; index++) { 36 | cin >> cost >> value; 37 | costs.push_back(cost); 38 | values.push_back(value); 39 | } 40 | cout << maxValue(costs, values, total_time) << endl; 41 | } 42 | 43 | int main() 44 | { 45 | solution51(); 46 | return 0; 47 | } -------------------------------------------------------------------------------- /code-set/52.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | // 完全背包问题 8 | // 一个矿能采无数次 9 | int maxValue(vector& costs, vector& values, int total_time) 10 | { 11 | int variety_number = costs.size(); // 矿物数量 12 | vector dp(total_time + 1); 13 | for (int iter = 1; iter <= variety_number; iter++) { 14 | for (int jter = costs[iter]; jter <= total_time; jter++) { 15 | dp[jter] = max( 16 | dp[jter - costs[iter]] + values[iter], 17 | dp[jter]); 18 | } 19 | } 20 | return dp[total_time]; 21 | } 22 | 23 | void solution52() 24 | { 25 | int total_time, variety_number; 26 | int cost, value; 27 | 28 | cin >> total_time >> variety_number; 29 | vector costs(variety_number + 1); 30 | vector values(variety_number + 1); 31 | for (int index = 1; index <= variety_number; index++) { 32 | cin >> cost >> value; 33 | costs.push_back(cost); 34 | values.push_back(value); 35 | } 36 | cout << maxValue(costs, values, total_time) << endl; 37 | } 38 | 39 | int main() 40 | { 41 | solution52(); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /code-set/53.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int x_direction[4] = { 0, 0, -1, 1 }; 8 | int y_direction[4] = { 1, -1, 0, 0 }; 9 | 10 | // 是否在题目区域内，若在，则返回true 11 | bool inArea(int x, int y, int row_length, int col_length) 12 | { 13 | if ((x >= 0 && y >= 0) && (x < row_length && y < col_length)) { 14 | return true; 15 | } else { 16 | return false; 17 | } 18 | } 19 | 20 | int maxDistance(vector>& matrix, vector>& max_distance, int x, int y) 21 | { 22 | int row_length = matrix.size(); 23 | int col_length = matrix[0].size(); 24 | if (max_distance[x][y] > 0) { 25 | return max_distance[x][y]; 26 | } 27 | max_distance[x][y] = 1; 28 | for (int iter = 0; iter < 4; iter++) { 29 | int to_x = x + x_direction[iter]; 30 | int to_y = y + y_direction[iter]; 31 | if (inArea(to_x, to_y, row_length, col_length) && matrix[x][y] > matrix[to_x][to_y]) { 32 | max_distance[x][y] = max( 33 | maxDistance(matrix, max_distance, to_x, to_y) + 1, 34 | max_distance[x][y]); 35 | } 36 | } 37 | return max_distance[x][y]; 38 | } 39 | 40 | void solution53() 41 | { 42 | int row, col; 43 | int max_dis = 0; 44 | cin >> row >> col; 45 | vector> matrix(row, vector(col)); 46 | vector> max_distance(row, vector(col)); // 判断是否经历过这个点 47 | for (int iter = 0; iter < row; iter++) { 48 | for (int jter = 0; jter < col; jter++) { 49 | cin >> matrix[iter][jter]; 50 | } 51 | } 52 | 53 | for (int iter = 0; iter < row; iter++) { 54 | for (int jter = 0; jter < col; jter++) { 55 | max_dis = max( 56 | maxDistance(matrix, max_distance, iter, jter), 57 | max_dis); 58 | } 59 | } 60 | cout << max_dis << endl; 61 | } 62 | 63 | int main() 64 | { 65 | solution53(); 66 | return 0; 67 | } -------------------------------------------------------------------------------- /code-set/56.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int order_number_pair(vector& arr) 8 | { 9 | if (arr.size() < 3) { 10 | return 0; 11 | } 12 | int count = 0; 13 | for (vector::iterator iter = arr.begin(); iter < arr.end(); iter++) { 14 | for (vector::iterator jter = iter + 1; jter < arr.end(); jter++) { 15 | for (vector::iterator kter = jter + 1; kter < arr.end(); kter++) { 16 | int difference1 = *jter - *iter; 17 | int difference2 = *kter - *jter; 18 | if ((difference1 > 0 && difference2 > 0) || (difference1 < 0 && difference2 < 0)) { 19 | count++; 20 | } 21 | } 22 | } 23 | } 24 | return count; 25 | } 26 | 27 | void solution56() 28 | { 29 | int n; 30 | 31 | cin >> n; 32 | vector array(n); 33 | for (vector::iterator iter = array.begin(); iter < array.end(); iter++) { 34 | cin >> *iter; 35 | } 36 | 37 | cout << order_number_pair(array) << endl; 38 | } 39 | 40 | int main() 41 | { 42 | solution56(); 43 | return 0; 44 | } -------------------------------------------------------------------------------- /code-set/57.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | bool solve(string& sentence, vector& words) 9 | { 10 | int sentence_length = sentence.size(); 11 | bool* dp = new bool[sentence_length + 1](); 12 | dp[0] = true; 13 | for (int i = 0; i < sentence_length; i++) { 14 | if (dp[i]) { 15 | for (int j = i; j < sentence_length; j++) { 16 | if (find(words.begin(), words.end(), sentence.substr(i, j - i + 1)) != words.end()) { 17 | dp[j + 1] = true; 18 | } 19 | } 20 | } 21 | } 22 | return dp[sentence_length]; 23 | } 24 | 25 | void solution57() 26 | { 27 | int words_number; 28 | string sentence; 29 | cin >> sentence >> words_number; 30 | vector words(words_number); 31 | for (vector::iterator iter = words.begin(); iter < words.end(); iter++) { 32 | cin >> *iter; 33 | } 34 | cout << (solve(sentence, words) ? "True" : "False") << endl; 35 | } 36 | 37 | int main() 38 | { 39 | solution57(); 40 | return 0; 41 | } -------------------------------------------------------------------------------- /code-set/61.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int maxIncreaseLength(vector& nums) 7 | { 8 | int nums_length = nums.size(); 9 | int max_increase_length = 0; 10 | vector dp(nums_length); 11 | for (int iter = 0; iter < nums_length; iter++) { 12 | for (int jter = 0; jter < iter; jter++) { 13 | if (nums[jter] < nums[iter]) { 14 | dp[iter] = max(dp[jter] + 1, dp[iter]); 15 | } 16 | } 17 | max_increase_length = max(dp[iter], max_increase_length); 18 | } 19 | return max_increase_length + 1; 20 | } 21 | 22 | void solution61() 23 | { 24 | int nums_length; 25 | cin >> nums_length; 26 | vector nums(nums_length); 27 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 28 | cin >> *(iter); 29 | } 30 | cout << maxIncreaseLength(nums) << endl; 31 | } 32 | 33 | int main() 34 | { 35 | solution61(); 36 | return 0; 37 | } 38 | 39 | /* sample input 40 | 11 41 | 10 9 2 5 3 7 101 18 17 19 102 42 | */ -------------------------------------------------------------------------------- /code-set/62.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int BST_number(int num) 6 | { 7 | vector kinds_number(num + 1); 8 | kinds_number[0] = 1; 9 | for (int iter = 1; iter <= num; iter++) { 10 | int kind_number = 0; 11 | for (int jter = 0; jter < iter; jter++) { 12 | kind_number += kinds_number[jter] * kinds_number[iter - jter - 1]; 13 | } 14 | kinds_number[iter] = kind_number; 15 | } 16 | return kinds_number[num]; 17 | } 18 | 19 | void solution62() 20 | { 21 | int num; 22 | cin >> num; 23 | cout << BST_number(num) << endl; 24 | } 25 | 26 | int main() 27 | { 28 | solution62(); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /code-set/66.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | import java.util.Vector; 3 | 4 | /** 5 | * @author ysxiang 6 | */ 7 | class Main { 8 | 9 | public static void main(String[] args) { 10 | Scanner scanner = new Scanner(System.in); 11 | int n = scanner.nextInt(); 12 | Vector heights = new Vector(); 13 | for (int iter = 0; iter < n; iter++) { 14 | heights.add(scanner.nextInt()); 15 | } 16 | System.out.println(new Main().solution(heights)); 17 | } 18 | 19 | public int solution(Vector heights) { 20 | int length = heights.size(); 21 | int maxVolume = 0; 22 | for (int frontFlag = 0; frontFlag < length - 1; frontFlag++) { 23 | for (int backFlag = frontFlag + 1; backFlag < length; backFlag++) { 24 | int minHeight = 25 | heights.get(frontFlag) < heights.get(backFlag) ? 26 | heights.get(frontFlag) : heights.get(backFlag); 27 | int volume = minHeight * (backFlag - frontFlag); 28 | maxVolume = volume > maxVolume ? volume : maxVolume; 29 | } 30 | } 31 | return maxVolume; 32 | } 33 | } -------------------------------------------------------------------------------- /code-set/69.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int maxSwingLength(vector& nums) 7 | { 8 | int nums_length = nums.size(); 9 | int up = 1, down = 1; 10 | for (int iter = 1; iter < nums_length; iter++) { 11 | if (nums[iter] > nums[iter - 1]) { 12 | up = down + 1; 13 | } 14 | if (nums[iter] < nums[iter - 1]) { 15 | down = up + 1; 16 | } 17 | } 18 | return max(up, down); 19 | } 20 | 21 | void solution69() 22 | { 23 | int nums_length; 24 | cin >> nums_length; 25 | vector nums(nums_length); 26 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 27 | cin >> *(iter); 28 | } 29 | cout << maxSwingLength(nums) << endl; 30 | } 31 | 32 | int main() 33 | { 34 | solution69(); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /code-set/70.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int splitIntoPairs(vector& nums) 7 | { 8 | int min_sum = 0; 9 | sort(nums.begin(), nums.end()); 10 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 11 | min_sum += *(iter++); 12 | } 13 | return min_sum; 14 | } 15 | 16 | void solution70() 17 | { 18 | int nums_length; 19 | cin >> nums_length; 20 | vector nums(nums_length); 21 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 22 | cin >> *(iter); 23 | } 24 | cout << splitIntoPairs(nums) << endl; 25 | } 26 | 27 | int main() 28 | { 29 | solution70(); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /code-set/71.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int mergeSheep(priority_queue, greater>& sheep_queue) 7 | { 8 | int sheep1, sheep2; 9 | int sum = 0; 10 | while (sheep_queue.size() > 1) { 11 | sheep1 = sheep_queue.top(); 12 | sheep_queue.pop(); 13 | sheep2 = sheep_queue.top(); 14 | sheep_queue.pop(); 15 | sum += sheep1 + sheep2; 16 | sheep_queue.push(sheep1 + sheep2); 17 | } 18 | return sum; 19 | } 20 | 21 | void solution71() 22 | { 23 | int sheep_queue_length; 24 | cin >> sheep_queue_length; 25 | priority_queue, greater> sheep_queue; // 优先队列，从小到大 26 | for (int iter = 0; iter < sheep_queue_length; iter++) { 27 | int sheep_number; 28 | cin >> sheep_number; 29 | sheep_queue.push(sheep_number); 30 | } 31 | cout << mergeSheep(sheep_queue) << endl; 32 | } 33 | 34 | int main() 35 | { 36 | solution71(); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /code-set/72.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int minCost(vector& toy_prices) 7 | { 8 | int toy_prices_length = toy_prices.size(); 9 | int total_price = 0; 10 | sort(toy_prices.begin(), toy_prices.end()); 11 | for (int iter = toy_prices_length - 1; iter >= 1; iter -= 3) { 12 | total_price += toy_prices[iter] + toy_prices[iter - 1]; 13 | } 14 | if (toy_prices_length % 3 == 1) { 15 | total_price += toy_prices[0]; 16 | } 17 | return total_price; 18 | } 19 | 20 | void solution72() 21 | { 22 | int toy_number; 23 | cin >> toy_number; 24 | vector toy_prices(toy_number); 25 | for (vector::iterator it = toy_prices.begin(); it < toy_prices.end(); it++) { 26 | cin >> *it; 27 | } 28 | cout << minCost(toy_prices) << endl; 29 | } 30 | 31 | int main() 32 | { 33 | solution72(); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /code-set/91.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | vector> result; 8 | void dfs(int n, int i, vector& path); 9 | 10 | void get_factors(int n) 11 | { 12 | if (n <= 3) { 13 | return; 14 | } 15 | vector path; 16 | dfs(n, 2, path); 17 | } 18 | 19 | void dfs(int n, int i, vector& path) 20 | { 21 | if (n == 1) { 22 | if (path.size() > 1) { 23 | result.push_back(vector(path)); 24 | } 25 | return; 26 | } 27 | for (int j = i; j <= n; j++) { 28 | if (n % j == 0) { 29 | path.push_back(j); 30 | dfs(n / j, j, path); 31 | path.erase(path.end() - 1); 32 | } 33 | } 34 | } 35 | 36 | void solution91() 37 | { 38 | int num; 39 | cin >> num; 40 | get_factors(num); 41 | for (vector>::iterator iter = result.begin(); iter < result.end(); iter++) { 42 | vector each_result = *iter; 43 | cout << "["; 44 | for (vector::iterator jter = each_result.begin(); jter < each_result.end() - 1; jter++) { 45 | cout << *jter << ", "; 46 | } 47 | cout << *(each_result.end() - 1) << "]" << endl; 48 | } 49 | } 50 | 51 | int main() 52 | { 53 | solution91(); 54 | return 0; 55 | } -------------------------------------------------------------------------------- /code-set/94.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | vector get_ip_address(string& str) 7 | { 8 | vector result; 9 | int len = str.size(); 10 | if (len < 4 || len > 12) { 11 | return result; 12 | } 13 | 14 | for (int i = 1; i < 4; i++) { 15 | for (int j = 1; j < 4; j++) { 16 | for (int k = 1; k < 4; k++) { 17 | for (int l = 1; l < 4; l++) { 18 | if (i + j + k + l == len) { 19 | int a = stoi(str.substr(0, i)); 20 | int b = stoi(str.substr(i, j)); 21 | int c = stoi(str.substr(i + j, k)); 22 | int d = stoi(str.substr(i + j + k, l)); 23 | if (a <= 255 && b <= 255 && c <= 255 && d <= 255) { 24 | string ip = to_string(a) + "." + to_string(b) + "." + to_string(c) + "." + to_string(d); 25 | if (ip.size() == len + 3) { 26 | result.push_back(ip); 27 | } 28 | } 29 | } 30 | } 31 | } 32 | } 33 | } 34 | return result; 35 | } 36 | 37 | void solution94() 38 | { 39 | string str; 40 | cin >> str; 41 | vector result_list = get_ip_address(str); 42 | for (vector::iterator iter = result_list.begin(); iter < result_list.end(); iter++) { 43 | cout << *iter << endl; 44 | } 45 | } 46 | 47 | int main() 48 | { 49 | solution94(); 50 | return 0; 51 | } -------------------------------------------------------------------------------- /code-set/96.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int dfs(string& str, int begin, set& unique_set) 8 | { 9 | if (begin == str.size()) { 10 | return 0; 11 | } 12 | int max_count = 0; 13 | for (int iter = begin; iter < str.size(); iter++) { 14 | string sub_str = str.substr(begin, iter - begin + 1); 15 | if (unique_set.find(sub_str) == unique_set.end()) { // if sub_str is not in unique_set. 16 | unique_set.insert(sub_str); 17 | max_count = max(max_count, 1 + dfs(str, iter + 1, unique_set)); 18 | unique_set.erase(sub_str); 19 | } 20 | } 21 | return max_count; 22 | } 23 | 24 | int max_unique_split(string& str) 25 | { 26 | set unique_set; 27 | return dfs(str, 0, unique_set); 28 | } 29 | 30 | void solution96() 31 | { 32 | string str; 33 | cin >> str; 34 | cout << max_unique_split(str) << endl; 35 | } 36 | 37 | int main() 38 | { 39 | solution96(); 40 | return 0; 41 | } -------------------------------------------------------------------------------- /draft/19.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int list[20001]; 6 | 7 | vector rightBigger(vector& nums) 8 | { 9 | int nums_length = nums.size(); 10 | vector res(nums_length, 0); // 保存结果 11 | 12 | for (int iter = nums_length - 1; iter >= 0; iter--) { 13 | list[nums[iter] + 10000] += 1; 14 | for (int jter = 0; jter < nums[iter] + 10000; jter++) { 15 | res[iter] += list[jter]; 16 | } 17 | } 18 | return res; 19 | } 20 | 21 | void solution19() 22 | { 23 | vector nums; 24 | int temp = 0; 25 | while (cin >> temp) //以任何字母为结束，输入中用q控制结束 26 | { 27 | nums.push_back(temp); //填充数据 28 | } 29 | vector countR = rightBigger(nums); 30 | for (int i = 0; i < countR.size() - 1; i++) { 31 | cout << countR[i] << " "; 32 | } 33 | cout << countR[countR.size() - 1] << endl; 34 | } 35 | 36 | int main() 37 | { 38 | solution19(); 39 | } -------------------------------------------------------------------------------- /draft/solution032.md: -------------------------------------------------------------------------------- 1 | # Problem 32 特殊数字 2 | 3 | TLE了 4 | 5 | 时间复杂度$O(n)$ 6 | 7 | ```cpp 8 | #include 9 | #include 10 | 11 | typedef long long ll; 12 | using namespace std; 13 | int figures[15]; 14 | 15 | // 特殊数字 16 | ll special_figure_count(ll low, ll high) 17 | { 18 | ll count = 0; 19 | for (ll iter = low; iter < high; iter++) { 20 | ll x = iter; 21 | int index = 0; 22 | memset(figures, 0, sizeof(figures)); 23 | while (x > 0) { 24 | int ones_unit = (int)(x % 10L); // 个位数 25 | x /= 10L; 26 | figures[index++] = ones_unit; 27 | } 28 | if ((index & 1) == 1) { // 为长度为基数 29 | int temp = figures[index >> 1]; 30 | if ((temp != 0 || temp != 1) || temp != 8) { 31 | continue; 32 | } 33 | } 34 | bool flag = true; 35 | for (int jter = 0; jter < ((index + 1) >> 1); jter++) { 36 | if (figures[jter] == 0 && figures[index - jter - 1] == 0) { 37 | continue; 38 | } 39 | if (figures[jter] == 1 && figures[index - jter - 1] == 1) { 40 | continue; 41 | } 42 | if (figures[jter] == 8 && figures[index - jter - 1] == 8) { 43 | continue; 44 | } 45 | if (figures[jter] == 9 && figures[index - jter - 1] == 6) { 46 | continue; 47 | } 48 | if (figures[jter] == 6 && figures[index - jter - 1] == 9) { 49 | continue; 50 | } 51 | flag = false; 52 | break; 53 | } 54 | if (!flag) { 55 | continue; 56 | } 57 | count++; 58 | } 59 | 60 | return count; 61 | } 62 | 63 | void solution32() 64 | { 65 | ll low; 66 | ll high; 67 | cin >> low >> high; 68 | cout << special_figure_count(low, high) << endl; 69 | } 70 | 71 | 72 | int main() 73 | { 74 | solution32(); 75 | return 0; 76 | } 77 | ``` 78 | 79 | -------------------------------------------------------------------------------- /make.sh: -------------------------------------------------------------------------------- 1 | # main.cpp 编译脚本 2 | g++ ./src/main.cpp -o ./target/main -------------------------------------------------------------------------------- /solutions/solution000.md: -------------------------------------------------------------------------------- 1 | **写在前面** 2 | 3 | 为大家祈福 4 | 5 | ```java 6 | // 7 | // _oo0oo_ 8 | // o8888888o 9 | // 88" . "88 10 | // (| -_- |) 11 | // 0\ = /0 12 | // ___/`---'\___ 13 | // .' \\| |// '. 14 | // / \\||| : |||// \ 15 | // / _||||| -:- |||||- \ 16 | // | | \\\ - /// | | 17 | // | \_| ''\---/'' |_/ | 18 | // \ .-\__ '-' ___/-. / 19 | // ___'. .' /--.--\ `. .'___ 20 | // ."" '< `.___\_<|>_/___.' >' "". 21 | // | | : `- \`.;`\ _ /`;.`/ - ` : | | 22 | // \ \ `_. \_ __\ /__ _/ .-` / / 23 | // =====`-.____`.___ \_____/___.-`___.-'===== 24 | // `=---=' 25 | // 26 | // 27 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 28 | // 29 | // 佛祖保佑 永无BUG 30 | // 31 | ``` -------------------------------------------------------------------------------- /solutions/solution001.md: -------------------------------------------------------------------------------- 1 | # Problem 01 最有意义的值h 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | public class Main { 7 | public static void main(String arg[]) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | 11 | int arr[] = new int[n]; 12 | for (int i = 0; i < n; i++) { 13 | arr[i] = snc.nextInt(); 14 | } 15 | Main main = new Main(); 16 | System.out.println(main.hIndex1(arr)); 17 | } 18 | 19 | /** 20 | * method 1: 排序 21 | * @param citations 22 | * @return 23 | */ 24 | public int hIndex1(int[] citations) { 25 | 26 | Arrays.sort(citations); 27 | int iter = citations.length - 1; 28 | int hIndex = 0; 29 | while (iter >= 0 && citations[iter] > hIndex) { // 如果citations[iter] > hIndex，则说明第iter + 1篇论文的引用数大于 h，符合条件，继续往下搜索。 30 | hIndex++; 31 | iter--; 32 | } 33 | return hIndex; 34 | } 35 | } 36 | ``` -------------------------------------------------------------------------------- /solutions/solution002.md: -------------------------------------------------------------------------------- 1 | # Problem 02 满足k的数对 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | public class Main { 7 | public static void main(String arg[]) { 8 | Scanner snc = new Scanner(System.in); 9 | 10 | int n = snc.nextInt(); 11 | int k = snc.nextInt(); 12 | int[] nums = new int[n]; 13 | for (int i = 0; i < n; i++) { 14 | nums[i] = snc.nextInt(); 15 | } 16 | System.out.println(k_dis(nums, k)); 17 | } 18 | 19 | /** 20 | * 利用HashMap方法 21 | * @param nums 22 | * @param k 23 | * @return 24 | */ 25 | public static int k_dis(int[] nums, int k) { 26 | int count = 0; 27 | int length = nums.length; 28 | HashMap hashMap = new HashMap(); 29 | for (int iter = 0; iter < length; iter++) { 30 | count += hashMap.getOrDefault( nums[iter] - k, 0) + hashMap.getOrDefault(nums[iter] + k, 0); 31 | hashMap.put(nums[iter], hashMap.getOrDefault(nums[iter], 0) + 1); 32 | } 33 | return count; 34 | } 35 | } 36 | ``` -------------------------------------------------------------------------------- /solutions/solution003.md: -------------------------------------------------------------------------------- 1 | # Problem 03 一共存了多少钱 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | public class Main { 7 | public static void main(String arg[]) { 8 | Scanner snc = new Scanner(System.in); 9 | int n = snc.nextInt(); 10 | System.out.println(totalMoney(n)); 11 | } 12 | 13 | public static int totalMoney(int n) { 14 | int week = n / 7; 15 | int day = n % 7; 16 | int total = 0; 17 | total = 28 * week + week * (week - 1) * 7 / 2; 18 | for (int iter = 0; iter < day; iter++) { 19 | total += week + iter + 1; 20 | } 21 | return total; 22 | } 23 | } 24 | ``` -------------------------------------------------------------------------------- /solutions/solution004.md: -------------------------------------------------------------------------------- 1 | # Problem 04 拆分正偶数 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | 11 | public static void main(String arg[]) { 12 | Scanner snc = new Scanner(System.in); 13 | int n = snc.nextInt(); 14 | System.out.println(maximumEvenSplit(n)); 15 | } 16 | 17 | public static List maximumEvenSplit(long finalSum) { 18 | ArrayList list = new ArrayList(); 19 | if (finalSum % 2 == 0) { 20 | long base = 2; 21 | list.add(base); 22 | finalSum = finalSum - 2; 23 | while (list.get(list.size() - 1) < finalSum) { 24 | base = base + 2; 25 | finalSum = finalSum - base; 26 | list.add(base); 27 | } 28 | list.set(list.size() - 1, list.get(list.size() - 1) + finalSum); 29 | } 30 | return list; 31 | } 32 | } 33 | ``` -------------------------------------------------------------------------------- /solutions/solution005.md: -------------------------------------------------------------------------------- 1 | # Problem 05 多少个数字1 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | public static void main(String[] args) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | Main main = new Main(); 14 | System.out.println(main.countDigitOne(n)); 15 | } 16 | 17 | /** 18 | * 计算1的个数 19 | * @param n 20 | * @return 21 | */ 22 | public int countDigitOne(int n) { 23 | String nString = String.valueOf(n); 24 | int nLength = nString.length(); 25 | if (nLength == 1) { 26 | if (n > 0) { 27 | return 1; 28 | } else { 29 | return 0; 30 | } 31 | } 32 | // 计算第i位前的数值，和第i位后的数值 33 | // 例如 abcde 则有 before[2] = ab; behind[2] = de 34 | int[] before = new int[nLength]; 35 | int[] behind = new int[nLength]; 36 | behind[0] = Integer.parseInt(nString.substring(1)); 37 | for (int iter = 1; iter < nLength - 1; iter++) { 38 | before[iter] = Integer.parseInt(nString.substring(0, iter)); 39 | behind[iter] = Integer.parseInt(nString.substring(iter + 1)); 40 | } 41 | before[nLength - 1] = Integer.parseInt(nString.substring(0, nLength - 1)); 42 | 43 | int digitOneCount = 0; 44 | for (int iter = 0; iter < nLength; iter++) { 45 | // x 为当前位数值，len 为当前位后面长度为多少 46 | int x = nString.charAt(iter) - '0'; 47 | int len = nLength - iter - 1; 48 | int prefix = before[iter]; 49 | int suffix = behind[iter]; 50 | int total = 0; 51 | // 当 c 前面的部分小于 ab 时 52 | total += prefix * intPow10(len); 53 | if (x == 0) { 54 | 55 | } else if (x == 1) { 56 | total += suffix + 1; 57 | } else { 58 | total += intPow10(len); 59 | } 60 | digitOneCount += total; 61 | } 62 | return digitOneCount; 63 | } 64 | 65 | /** 66 | * 等价于 pow(10, index) 67 | * @param index 68 | * @return 69 | */ 70 | public int intPow10 (int index) { 71 | if (index == 0) { 72 | return 1; 73 | } else { 74 | int powResult = 1; 75 | while (index > 0) { 76 | powResult *= 10; 77 | index--; 78 | } 79 | return powResult; 80 | } 81 | } 82 | } 83 | ``` -------------------------------------------------------------------------------- /solutions/solution006.md: -------------------------------------------------------------------------------- 1 | # Problem 06 连续整数求和 2 | 3 | ```java 4 | mport java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | public static void main(String arg[]) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | Main main = new Main(); 14 | System.out.println(main.consecutiveNumbersSum(n)); 15 | } 16 | 17 | /** 18 | * 设连续数列首项为a，公差为1，共k项。 19 | * 有 ka + k * (k - 1) /2 = n 20 | * k ^ 2 + 2 * k * a- k = 2n 21 | * 2a = 2n/k - k + 1 >= 2 22 | * @param n 23 | * @return 24 | */ 25 | public int consecutiveNumbersSum(int n) { 26 | int count = 0; 27 | int nMulti2 = n * 2; 28 | for (int k = 1; k * k < nMulti2; k++) { 29 | if (nMulti2 % k != 0) { 30 | continue; 31 | } 32 | if ((nMulti2 / k - k + 1) % 2 ==0) { 33 | count++; 34 | } 35 | } 36 | return count; 37 | } 38 | } 39 | ``` -------------------------------------------------------------------------------- /solutions/solution007.md: -------------------------------------------------------------------------------- 1 | # Problem 07 个位数之和 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | 11 | public static void main(String arg[]) { 12 | Scanner snc = new Scanner(System.in); 13 | int n = snc.nextInt(); 14 | int k = snc.nextInt(); 15 | Main main = new Main(); 16 | System.out.println(main.minimumNumbers(n, k)); 17 | } 18 | 19 | public int minimumNumbers(int num, int k) { 20 | if (num == 0) { 21 | return 0; 22 | } else { 23 | for (int iter = 1; iter <= 10; iter++) { 24 | if (iter * k <= num && (num - iter * k) % 10 == 0) { 25 | return iter; 26 | } 27 | } 28 | return -1; 29 | } 30 | } 31 | } 32 | ``` -------------------------------------------------------------------------------- /solutions/solution008.md: -------------------------------------------------------------------------------- 1 | # Problem 08 2的幂 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | 11 | private HashSet hashSet = new HashSet(); 12 | 13 | public static void main(String arg[]) { 14 | Scanner snc = new Scanner(System.in); 15 | int n = snc.nextInt(); 16 | Main main = new Main(); 17 | System.out.println(main.reorderedPowerOf2(n)); 18 | } 19 | 20 | public boolean reorderedPowerOf2(int n) { 21 | for (int num = 1; num <= (int)1e9; num <<= 1) { 22 | hashSet.add(countDigits(num)); 23 | } 24 | return hashSet.contains(countDigits(n)); 25 | } 26 | 27 | public String countDigits(int num) { 28 | char[] countDigitsResult = new char[10]; 29 | while (num > 0) { 30 | countDigitsResult[num % 10]++; 31 | num = num / 10; 32 | } 33 | return new String(countDigitsResult); 34 | } 35 | } 36 | ``` -------------------------------------------------------------------------------- /solutions/solution009.md: -------------------------------------------------------------------------------- 1 | # Problem 09 数组间的最大距离 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | public class Main { 7 | 8 | public static void main(String arg[]) { 9 | Scanner snc = new Scanner(System.in); 10 | int n = snc.nextInt(); 11 | int arr[] = new int[n]; 12 | for (int i = 0; i < n; i++) { 13 | arr[i] = snc.nextInt(); 14 | } 15 | Main main = new Main(); 16 | System.out.println(main.maximumGap(arr)); 17 | } 18 | 19 | public int maximumGap(int[] nums) { 20 | Arrays.sort(nums); 21 | int maxGap = 0; 22 | for (int iter = 0; iter < nums.length - 1; iter++) { 23 | if (nums[iter + 1] - nums[iter] > maxGap) { 24 | maxGap = nums[iter + 1] - nums[iter]; 25 | } 26 | } 27 | return maxGap; 28 | } 29 | } 30 | ``` 31 | -------------------------------------------------------------------------------- /solutions/solution010.md: -------------------------------------------------------------------------------- 1 | # Problem 10 找到对应的列名 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | import java.util.*; 10 | 11 | public class Main { 12 | public static void main(String arg[]) { 13 | Scanner snc = new Scanner(System.in); 14 | int n = snc.nextInt(); 15 | Main main = new Main(); 16 | System.out.println(main.convertToTitle(n)); 17 | } 18 | 19 | public String convertToTitle(int columnNumber) { 20 | StringBuffer title = new StringBuffer(); 21 | while (columnNumber > 0) { 22 | title.insert(0, String.valueOf((char) ((columnNumber - 1) % 26 + Integer.valueOf('A')))); 23 | columnNumber = (columnNumber - 1)/ 26; 24 | } 25 | return new String(title); 26 | } 27 | } 28 | ``` -------------------------------------------------------------------------------- /solutions/solution011.md: -------------------------------------------------------------------------------- 1 | # Problem 11 n = k^x ? （n是k的幂吗） 2 | 3 | 4 | ## Java Solution 5 | 6 | ```java 7 | import java.util.*; 8 | 9 | /** 10 | * @author ysxiang 11 | */ 12 | 13 | public class Main { 14 | public static void main(String arg[]) { 15 | Scanner snc = new Scanner(System.in); 16 | int n = snc.nextInt(); 17 | int k = snc.nextInt(); 18 | Main main = new Main(); 19 | System.out.println(main.isNAPowerOfK(n, k)); 20 | } 21 | 22 | public int isNAPowerOfK(int n, int k) { 23 | if (n < k) { 24 | if (n == 1) { 25 | return 1; 26 | } else { 27 | return 0; 28 | } 29 | } else if (n == k) { 30 | return 1; 31 | } else if (k == 1) { 32 | return 0; 33 | } else { 34 | for (int iter = k; iter <= n; iter *= k) { 35 | if (iter < n) { 36 | continue; 37 | } else { 38 | return 1; 39 | } 40 | } 41 | return 0; 42 | } 43 | } 44 | } 45 | ``` 46 | 47 | ## Cpp Solution 48 | 49 | ```cpp 50 | #include 51 | 52 | using namespace std; 53 | 54 | bool isNAPowerOfK(int n, int k); 55 | 56 | int main() 57 | { 58 | int n = 0, k = 0; 59 | cin >> n >> k; 60 | cout << isNAPowerOfK(n, k) << endl; 61 | return 0; 62 | } 63 | 64 | bool isNAPowerOfK(int n, int k) 65 | { 66 | if (n < k) { 67 | if (n == 1) { 68 | return true; 69 | } else { 70 | return false; 71 | } 72 | } else if (n == k) { 73 | return true; 74 | } else if (k == 1) { 75 | return false; 76 | } else { 77 | int product = k; 78 | while (product < n) { 79 | product *= product; 80 | } 81 | if (product == n) { 82 | return true; 83 | } else { 84 | while (product > n) { 85 | product /= k; 86 | } 87 | if (product == n) { 88 | return true; 89 | } 90 | } 91 | return false; 92 | } 93 | } 94 | ``` -------------------------------------------------------------------------------- /solutions/solution012.md: -------------------------------------------------------------------------------- 1 | # Problem 12 类菲波拉契数 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | public static void main(String[] args) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | System.out.println(Fibonacci(n)); 14 | } 15 | 16 | public static int Fibonacci(int n) { 17 | int H0 = 0, H1 = 1, H2 = 1; 18 | for (int iter = 0; iter < n / 3; iter++) { 19 | int temp0 = H0 + H1 + H2; 20 | int temp1 = temp0 + H1 + H2; 21 | int temp2 = temp0 + temp1 + H2; 22 | H0 = temp0; 23 | H1 = temp1; 24 | H2 = temp2; 25 | } 26 | switch (n % 3) { 27 | case 0: 28 | return H0; 29 | case 1: 30 | return H1; 31 | case 2: 32 | return H2; 33 | default: 34 | return -1; 35 | } 36 | } 37 | } 38 | ``` -------------------------------------------------------------------------------- /solutions/solution013.md: -------------------------------------------------------------------------------- 1 | # Problem 13 前n项和 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | public class Main { 7 | 8 | public static void main(String arg[]) { 9 | Scanner snc = new Scanner(System.in); 10 | int n = snc.nextInt(); 11 | 12 | Main main = new Main(); 13 | System.out.println(main.addSumOfN(n)); 14 | } 15 | 16 | public int addSumOfN(int n) { 17 | return (1 + n) * n / 2; 18 | } 19 | } 20 | ``` -------------------------------------------------------------------------------- /solutions/solution014.md: -------------------------------------------------------------------------------- 1 | # Problem 14 归一次数 2 | 3 | ```java 4 | import java.util.Scanner; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | class Main { 10 | public static int backOne(int n) { 11 | if (n == 1) { 12 | return 0; 13 | } else { 14 | if (n % 2 == 0) { 15 | return backOne(n / 2) + 1; 16 | } else { 17 | int biggerOne = backOne(n + 1) + 1; 18 | int smallerOne = backOne(n - 1) + 1; 19 | if (biggerOne > smallerOne) { 20 | return smallerOne; 21 | } else { 22 | return biggerOne; 23 | } 24 | } 25 | } 26 | } 27 | 28 | public static void main(String[] args) { 29 | Scanner scanner = new Scanner(System.in); 30 | int n = scanner.nextInt(); 31 | System.out.println(backOne(n)); 32 | } 33 | } 34 | ``` -------------------------------------------------------------------------------- /solutions/solution015.md: -------------------------------------------------------------------------------- 1 | # Problem 15 运算结果 2 | 3 | ## Solution 4 | 5 | ```java 6 | import java.util.Scanner; 7 | import java.util.Stack; 8 | 9 | /** 10 | * OJ 11 | * 12 | * @author ysxiang 13 | */ 14 | class Main { 15 | public static void main(String[] args) { 16 | Scanner scanner = new Scanner(System.in); 17 | String str = scanner.nextLine(); 18 | System.out.println(new Main().calculateResult(str.toCharArray())); 19 | } 20 | 21 | /** 22 | * Calculate the result. 23 | * @param chars 24 | */ 25 | public char calculateResult(char[] chars) { 26 | Stack stack = new Stack<>(); 27 | int charsLength = chars.length; 28 | for (int iter = charsLength - 1; iter >= 0; iter--) { 29 | if (chars[iter] == ':') { 30 | stack.push(chars[--iter]); 31 | } else if (chars[iter] == '?') { 32 | char temp = stack.pop(); 33 | if (chars[--iter] == 'T') { 34 | stack.pop(); 35 | stack.push(temp); 36 | } 37 | } else { 38 | stack.push(chars[iter]); 39 | } 40 | } 41 | return stack.peek(); 42 | } 43 | } 44 | ``` -------------------------------------------------------------------------------- /solutions/solution016.md: -------------------------------------------------------------------------------- 1 | # Problem 16 "有效子数组"个数 2 | 3 | 感觉我这个方法算法太傻了，得用cpp才能过 4 | 5 | ```cpp 6 | /** 7 | * 因为有些题用java写会RE，但用cpp就没问题 8 | * @author ysxiang 9 | */ 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | using namespace std; 16 | 17 | int effectiveSub(std::vector &nums); 18 | 19 | void task16() 20 | { 21 | string str; 22 | 23 | getline(cin, str); 24 | 25 | vector chars; 26 | for (int i = 0; i < str.length(); i += 2) 27 | { 28 | if (str.at(i) != 'q') 29 | { 30 | chars.push_back(str.at(i) - '0'); 31 | } 32 | } 33 | 34 | std::cout << effectiveSub(chars) << std::endl; 35 | 36 | return; 37 | } 38 | 39 | int effectiveSub(std::vector &nums) 40 | { 41 | int nums_length = nums.size(); 42 | int sub_count = 0; 43 | for (int i = 0; i <= nums_length; i++) 44 | { 45 | for (int j = i; j <= nums_length; j++) 46 | { 47 | int zero_count = 0; 48 | int one_count = 0; 49 | for (int k = i; k < j; k++) 50 | { 51 | if (nums[k]) 52 | { 53 | one_count++; 54 | } 55 | else 56 | { 57 | zero_count++; 58 | } 59 | } 60 | 61 | if (one_count > zero_count) 62 | { 63 | sub_count++; 64 | } 65 | } 66 | } 67 | return sub_count; 68 | } 69 | 70 | int main() 71 | { 72 | task16(); 73 | } 74 | ``` 75 | 76 | 后来听说这个方法也会超时，估计是数据量变大了，不能用暴力法偷懒了QAQ 77 | 所以又搞了一个时间复杂度为 O(nlogn) 的算法 78 | 79 | ```cpp 80 | /** 81 | * @author ysxiang 82 | */ 83 | #include 84 | #include 85 | 86 | using namespace std; 87 | 88 | int effectiveSub(std::vector& nums); 89 | void solution16(); 90 | int lowbit(int x); 91 | void add(int x, int v, int n); 92 | int query(int x); 93 | 94 | static constexpr int MOD = 1000000007; 95 | static vector tree(200010); 96 | 97 | void solution16() 98 | { 99 | int temp; 100 | vector chars; 101 | while (cin >> temp) { 102 | chars.push_back(temp); 103 | } 104 | std::cout << effectiveSub(chars) << std::endl; 105 | return; 106 | } 107 | 108 | int lowbit(int x) 109 | { 110 | return x & -x; 111 | } 112 | 113 | int query(int x) 114 | { 115 | int ans = 0; 116 | for (int iter = x; iter > 0; iter -= lowbit(iter)) { 117 | ans += tree[iter]; 118 | } 119 | return ans; 120 | } 121 | 122 | void add(int x, int v, int n) 123 | { 124 | for (int iter = x; iter <= 2 * n + 1; iter += lowbit(iter)) { 125 | tree[iter] += v; 126 | } 127 | } 128 | 129 | int effectiveSub(std::vector& nums) 130 | { 131 | int nums_length = nums.size(); 132 | vector sum(nums_length + 1); 133 | int sub_count = 0; 134 | for (int iter = 1; iter <= nums_length; iter++) { 135 | sum[iter] = sum[iter - 1] + ((nums[iter - 1] == 0) ? -1 : 1); // 将nums数组的[0, 1]映射到[-1, 1],并累加 136 | } 137 | for (int iter = 0; iter <= nums_length; iter++) { 138 | int temp = sum[iter] + nums_length + 1; // [-n, n] -> [1, 2n + 1] 139 | sub_count = (sub_count + query(temp - 1)) % MOD; 140 | add(temp, 1, nums_length); 141 | } 142 | 143 | return sub_count; 144 | } 145 | 146 | int main() 147 | { 148 | solution16(); 149 | } 150 | ``` -------------------------------------------------------------------------------- /solutions/solution017.md: -------------------------------------------------------------------------------- 1 | # Problem 17 最少取几个数 2 | 3 | ```java 4 | import java.util.ArrayList; 5 | import java.util.Scanner; 6 | 7 | /** 8 | * @author ysxiang 9 | */ 10 | class Main { 11 | 12 | public int getSteps( 13 | ArrayList nums, 14 | int currentSum, int targetSum, 15 | int frontFlag, int backFlag 16 | ) { 17 | if (currentSum > targetSum) { 18 | return -1; 19 | } else if (currentSum == targetSum) { 20 | return 1; 21 | } else { 22 | if (frontFlag < backFlag) { 23 | int front2back = getSteps( // 从前往后 24 | nums, 25 | currentSum + nums.get(frontFlag), targetSum, 26 | frontFlag + 1, backFlag 27 | ); 28 | int back2front = getSteps( // 从后往前 29 | nums, 30 | currentSum + nums.get(backFlag - 1), targetSum, 31 | frontFlag, backFlag - 1 32 | ); 33 | if (front2back == -1 && back2front == -1) { 34 | return -1; 35 | } else if (front2back == -1) { 36 | return back2front + 1; 37 | } else if (back2front == -1) { 38 | return front2back + 1; 39 | } else { 40 | if (back2front > front2back) { 41 | return front2back + 1; 42 | } else { 43 | return back2front + 1; 44 | } 45 | } 46 | } else { 47 | return -1; 48 | } 49 | } 50 | } 51 | 52 | public int minSelect(int targetSum, ArrayList nums) { 53 | if (nums.size() >= 2) { 54 | int front2back = getSteps( // 从前往后 55 | nums, 56 | nums.get(0), targetSum, 57 | 1, nums.size()); 58 | int back2front = getSteps( // 从后往前 59 | nums, 60 | nums.get(nums.size() - 1), targetSum, 61 | 0, nums.size() - 1 62 | ); 63 | if (front2back == -1 && back2front == -1) { 64 | return -1; 65 | } else if (front2back == -1) { 66 | return back2front; 67 | } else if (back2front == -1) { 68 | return front2back; 69 | } else { 70 | if (back2front > front2back) { 71 | return front2back; 72 | } else { 73 | return back2front; 74 | } 75 | } 76 | } else if (nums.size() == 1) { 77 | if (nums.get(0) == targetSum) { 78 | return 1; 79 | } 80 | } 81 | return -1; 82 | } 83 | 84 | public static void main(String[] args) { 85 | Scanner scanner = new Scanner(System.in); 86 | int targetSum = scanner.nextInt(); 87 | String numStr = ""; 88 | ArrayList nums = new ArrayList(); 89 | while ((numStr = scanner.next()).equals("q") == false) { 90 | nums.add(Integer.parseInt(numStr)); 91 | } 92 | System.out.println(new Main().minSelect(targetSum, nums)); 93 | } 94 | } 95 | ``` -------------------------------------------------------------------------------- /solutions/solution018.md: -------------------------------------------------------------------------------- 1 | # Problem 18 真还是假？ 2 | 3 | ## Solution 4 | 5 | ```java 6 | import java.util.Scanner; 7 | import java.util.Stack; 8 | 9 | /** 10 | * OJ 11 | * 12 | * @author ysxiang 13 | */ 14 | class Main { 15 | public static void main(String[] args) { 16 | Scanner scanner = new Scanner(System.in); 17 | String str = scanner.nextLine(); 18 | System.out.println(new Main().trueOrFalse(str.toCharArray())); 19 | } 20 | 21 | /** 22 | * judge expression is true or false. 23 | * 24 | * @param chars 字符数组 25 | */ 26 | public int trueOrFalse(char[] chars) { 27 | Stack numbers = new Stack<>(); 28 | Stack operations = new Stack<>(); 29 | for (char charIter : chars) { 30 | switch (charIter) { 31 | case '|': 32 | case '&': 33 | case '!': 34 | operations.push(charIter); 35 | break; 36 | case 't': 37 | case 'f': 38 | case '(': 39 | numbers.push(charIter); 40 | break; 41 | case ')': 42 | boolean tempFlag = false; 43 | char number; 44 | switch (operations.pop()) { 45 | case '|': 46 | tempFlag = false; 47 | while ((number = numbers.pop()) != '(') { 48 | tempFlag |= (number == 't'); 49 | } 50 | numbers.push(tempFlag ? 't' : 'f'); 51 | break; 52 | case '&': 53 | tempFlag = true; 54 | while ((number = numbers.pop()) != '(') { 55 | tempFlag &= (number == 't'); 56 | } 57 | numbers.push(tempFlag ? 't' : 'f'); 58 | break; 59 | case '!': 60 | while ((number = numbers.pop()) != '(') { 61 | tempFlag = (number != 't'); 62 | } 63 | numbers.push(tempFlag ? 't' : 'f'); 64 | break; 65 | } 66 | default: 67 | break; 68 | } 69 | } 70 | 71 | if (numbers.pop() == 't') { 72 | return 1; 73 | } else { 74 | return 0; 75 | } 76 | } 77 | } 78 | ``` -------------------------------------------------------------------------------- /solutions/solution019.md: -------------------------------------------------------------------------------- 1 | # Problem 19 比几个数大 2 | 3 | ```java 4 | import java.util.ArrayList; 5 | import java.util.Scanner; 6 | 7 | /** 8 | * @author ysxiang 9 | */ 10 | class Main { 11 | public ArrayList rightBigger(ArrayList nums) { 12 | ArrayList targetNums = new ArrayList(); 13 | for (int iter = 0; iter < nums.size(); iter++) { 14 | int iterNum = nums.get(iter); 15 | int count = 0; 16 | for (int j = iter + 1; j < nums.size(); j++) { 17 | if (iterNum > nums.get(j)) { 18 | count++; 19 | } 20 | } 21 | targetNums.add(count); 22 | } 23 | 24 | return targetNums; 25 | } 26 | 27 | public static void main(String[] args) { 28 | Scanner scanner = new Scanner(System.in); 29 | String numStr = ""; 30 | ArrayList nums = new ArrayList(); 31 | while ((numStr = scanner.next()).equals("q") == false) { 32 | nums.add(Integer.parseInt(numStr)); 33 | } 34 | ArrayList targetNums = new Main().rightBigger(nums); 35 | for (int iter = 0; iter < targetNums.size() - 1; iter++) { 36 | System.out.print(targetNums.get(iter) + " "); 37 | } 38 | System.out.println(targetNums.get(targetNums.size() - 1)); 39 | } 40 | } 41 | ``` -------------------------------------------------------------------------------- /solutions/solution020.md: -------------------------------------------------------------------------------- 1 | # Problem 20 英文读数 2 | 3 | ```java 4 | import java.util.Scanner; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | class Main { 10 | public final static int N_MAX = 2_000_000_000; 11 | public final static String[] singles = {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}; 12 | public final static String[] teens = {"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"}; 13 | public final static String[] tens = {"Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"}; 14 | public final static String[] thousands = {"", "Thousand", "Million", "Billion"}; 15 | 16 | public void recursion(StringBuffer currentStr, int num) { 17 | if (num == 0) { 18 | return; 19 | } else if (num < 10) { 20 | currentStr.append(singles[num - 1]).append(" "); 21 | } else if (num < 20) { 22 | currentStr.append(teens[num - 10]).append(" "); 23 | } else if (num < 100) { 24 | currentStr.append(tens[num / 10 - 1]).append(" "); 25 | recursion(currentStr, num % 10); 26 | } else { 27 | currentStr.append(singles[num / 100 - 1]).append(" Hundred "); 28 | recursion(currentStr, num % 100); 29 | } 30 | } 31 | 32 | 33 | public String translateNumber (int num) { 34 | if(num == 0) { 35 | return "Zero"; 36 | } 37 | StringBuffer sb = new StringBuffer(); 38 | for (int i = 3, unit = 1_000_000_000; i >= 0; i--, unit /= 1000) { 39 | int currentNum = num / unit; 40 | if (currentNum != 0) { 41 | num -= currentNum * unit; 42 | StringBuffer currentStr = new StringBuffer(); 43 | recursion(currentStr, currentNum); 44 | currentStr.append(thousands[i]).append(" "); 45 | sb.append(currentStr); 46 | } 47 | } 48 | return sb.toString().trim(); 49 | } 50 | 51 | public static void main(String[] args) { 52 | Scanner scanner = new Scanner(System.in); 53 | int num = scanner.nextInt(); 54 | System.out.println(new Main().translateNumber(num)); 55 | } 56 | } 57 | ``` -------------------------------------------------------------------------------- /solutions/solution021.md: -------------------------------------------------------------------------------- 1 | # Problem 21 数字消消乐 2 | 3 | ## Solution 4 | 5 | 这题的递归解法真的好牛 6 | 7 | ```java 8 | import java.util.Scanner; 9 | 10 | /** 11 | * OJ 12 | * Dynamic Programming 13 | * 14 | * @author ysxiang 15 | */ 16 | class Main { 17 | public static void main(String[] args) { 18 | Scanner sn = new Scanner(System.in); 19 | int inputValue = sn.nextInt(); 20 | System.out.println(new Main().lastRemaining(inputValue)); 21 | } 22 | 23 | /** 24 | * @param n 数组长度 25 | * @param fromLeft ture 从左到右，false从右到左 26 | * @return 27 | */ 28 | public int recursion(int n, boolean fromLeft) { 29 | if (n == 1) { 30 | return 1; 31 | } 32 | if (fromLeft) { 33 | return 2 * recursion(n / 2, false); // 剩下的都是双数 34 | } else { 35 | if (n % 2 == 1) { 36 | return 2 * recursion(n / 2, true); 37 | } else { 38 | return 2 * recursion(n / 2, true) - 1; 39 | } 40 | } 41 | } 42 | 43 | public int lastRemaining(int n) { 44 | return recursion(n, true); // 先从左到右 45 | } 46 | } 47 | ``` -------------------------------------------------------------------------------- /solutions/solution022.md: -------------------------------------------------------------------------------- 1 | # Problem 22 算一个斐波那契数列吧 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | public static void main(String[] args) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | System.out.println(getFibonacci(n)); 14 | } 15 | 16 | public static int getFibonacci(int n) { 17 | int H0 = 0, H1 = 1; 18 | for (int iter = 0; iter < n / 2; iter++) { 19 | int temp0 = H0 + H1; 20 | int temp1 = temp0 + H1; 21 | H0 = temp0; 22 | H1 = temp1; 23 | } 24 | switch (n % 2) { 25 | case 0: 26 | return H0; 27 | case 1: 28 | return H1; 29 | default: 30 | return -1; 31 | } 32 | } 33 | } 34 | ``` -------------------------------------------------------------------------------- /solutions/solution023.md: -------------------------------------------------------------------------------- 1 | # Problem 23 1出现了几次？ 2 | 3 | ```java 4 | import java.util.*; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main { 10 | public static void main(String[] args) { 11 | Scanner snc = new Scanner(System.in); 12 | int n = snc.nextInt(); 13 | Main main = new Main(); 14 | System.out.println(main.countDigitOne(n)); 15 | } 16 | 17 | /** 18 | * 计算1的个数 19 | * @param n 20 | * @return 21 | */ 22 | public int countDigitOne(int n) { 23 | String nString = String.valueOf(n); 24 | int nLength = nString.length(); 25 | if (nLength == 1) { 26 | if (n > 0) { 27 | return 1; 28 | } else { 29 | return 0; 30 | } 31 | } 32 | // 计算第i位前的数值，和第i位后的数值 33 | // 例如 abcde 则有 before[2] = ab; behind[2] = de 34 | int[] before = new int[nLength]; 35 | int[] behind = new int[nLength]; 36 | behind[0] = Integer.parseInt(nString.substring(1)); 37 | for (int iter = 1; iter < nLength - 1; iter++) { 38 | before[iter] = Integer.parseInt(nString.substring(0, iter)); 39 | behind[iter] = Integer.parseInt(nString.substring(iter + 1)); 40 | } 41 | before[nLength - 1] = Integer.parseInt(nString.substring(0, nLength - 1)); 42 | 43 | int digitOneCount = 0; 44 | for (int iter = 0; iter < nLength; iter++) { 45 | // x 为当前位数值，len 为当前位后面长度为多少 46 | int x = nString.charAt(iter) - '0'; 47 | int len = nLength - iter - 1; 48 | int prefix = before[iter]; 49 | int suffix = behind[iter]; 50 | int total = 0; 51 | // 当 c 前面的部分小于 ab 时 52 | total += prefix * intPow10(len); 53 | if (x == 0) { 54 | 55 | } else if (x == 1) { 56 | total += suffix + 1; 57 | } else { 58 | total += intPow10(len); 59 | } 60 | digitOneCount += total; 61 | } 62 | return digitOneCount; 63 | } 64 | 65 | /** 66 | * 等价于 pow(10, index) 67 | * @param index 68 | * @return 69 | */ 70 | public int intPow10 (int index) { 71 | if (index == 0) { 72 | return 1; 73 | } else { 74 | int powResult = 1; 75 | while (index > 0) { 76 | powResult *= 10; 77 | index--; 78 | } 79 | return powResult; 80 | } 81 | } 82 | } 83 | ``` -------------------------------------------------------------------------------- /solutions/solution024.md: -------------------------------------------------------------------------------- 1 | # Problem 24 是二叉搜索树吗？ 2 | 3 | tag: 递归 4 | 5 | ## solution 6 | 7 | ```cpp 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | // 二叉搜索树 13 | int index = 0; 14 | int arr[2000]; 15 | bool is_end = false; 16 | 17 | bool judgeBST(int start, int end) 18 | { 19 | if (start >= end) { 20 | return true; 21 | } 22 | int middle = end; 23 | for (int iter = start; iter < end; iter++) { 24 | if (arr[iter] > arr[end]) { 25 | middle = iter; 26 | break; 27 | } 28 | } 29 | if (middle == end) { 30 | return judgeBST(start, end - 1); 31 | } 32 | for (int iter = middle; iter < end; iter++) { 33 | if (arr[iter] < arr[end]) { 34 | return false; 35 | } 36 | } 37 | if (start == middle) { 38 | return judgeBST(middle, end - 1); 39 | } 40 | return judgeBST(start, middle - 1) && judgeBST(middle, end - 1); 41 | } 42 | 43 | int read() 44 | { 45 | char ch = getchar(); 46 | while (ch < '0' || ch > '9') { 47 | ch = getchar(); 48 | } 49 | int number = 0; 50 | while (ch >= '0' && ch <= '9') { 51 | number = number * 10 + ch - '0'; 52 | ch = getchar(); 53 | } 54 | if (ch == ']') { 55 | is_end = true; 56 | } 57 | return number; 58 | } 59 | 60 | void solution24() 61 | { 62 | while (!is_end) { 63 | arr[index++] = read(); 64 | } 65 | if (judgeBST(0, index - 1)) { 66 | cout << "true" << endl; 67 | } else { 68 | cout << "false" << endl; 69 | } 70 | } 71 | 72 | int main() 73 | { 74 | solution24(); 75 | return 0; 76 | } 77 | ``` -------------------------------------------------------------------------------- /solutions/solution025.md: -------------------------------------------------------------------------------- 1 | # Problem 25 max(好因子) 2 | 3 | ```java 4 | import java.util.Scanner; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main{ 10 | private final static int N = 1_000_000_007; 11 | 12 | public static void main(String[] args) { 13 | Scanner scanner = new Scanner(System.in); 14 | int n = scanner.nextInt(); 15 | System.out.println(new Main().getGoodDivisor(n)); 16 | } 17 | 18 | /** 19 | * solution. 20 | */ 21 | public int getGoodDivisor(int n) { 22 | 23 | if (n <= 3) { 24 | return n; 25 | } 26 | int a = n / 3, b = n % 3; 27 | if (b == 1) { 28 | return (int) (quickPow(3, a - 1, N) * 4 % N); 29 | } else if (b == 2) { 30 | return (int) (quickPow(3, a, N) * 2 % N); 31 | } else { 32 | return (int) quickPow(3, a, N); 33 | } 34 | } 35 | 36 | 37 | /** 38 | * 快速求幂： 39 | * p^q，计算中防止溢出，对MOD求余 40 | */ 41 | public long quickPow(int p, int q, int MOD) { 42 | long ans = 1L; 43 | long base = p; 44 | while (q != 0) { 45 | if (q % 2 == 1) { 46 | ans = ans * base % MOD; 47 | } 48 | base = base * base % MOD; 49 | q = q / 2; 50 | } 51 | return ans; 52 | } 53 | } 54 | ``` -------------------------------------------------------------------------------- /solutions/solution027.md: -------------------------------------------------------------------------------- 1 | # Problem 27 最小非零乘积 2 | 3 | ## Solution 4 | 5 | ```java 6 | import java.util.Scanner; 7 | 8 | /** 9 | * OJ 10 | * 11 | * @author ysxiang 12 | */ 13 | public class Main { 14 | public final static long MOD = 1_000_000_007; 15 | 16 | public int minNonZeroProduct(int index) { 17 | long a = (1L << index) - 1L; 18 | long b = a - 1L; 19 | long c = b / 2L; 20 | return (int) ((a % MOD) * (quickPow(b % MOD, c)) % MOD); 21 | } 22 | 23 | /** 24 | * 快速幂 25 | * 26 | * @param a 27 | * @param index 28 | * @return 29 | */ 30 | public long quickPow(long a, long index) { 31 | long base = a; 32 | long ans = 1L; 33 | while (index > 0) { 34 | if ((index & 1L) == 1L) { 35 | ans = (ans * base) % MOD; 36 | } 37 | base = (base * base) % MOD; 38 | index >>= 1; 39 | } 40 | return ans; 41 | } 42 | 43 | public static void main(String[] args) { 44 | Scanner scanner = new Scanner(System.in); 45 | int p = scanner.nextInt(); 46 | System.out.println(new Main().minNonZeroProduct(p)); 47 | } 48 | } 49 | 50 | ``` -------------------------------------------------------------------------------- /solutions/solution028.md: -------------------------------------------------------------------------------- 1 | # Problem 28 二进制的第K位 2 | 3 | ```java 4 | import java.util.Scanner; 5 | 6 | /** 7 | * @author ysxiang 8 | */ 9 | public class Main{ 10 | public static void main(String[] args) { 11 | Scanner scanner = new Scanner(System.in); 12 | int n = scanner.nextInt(); 13 | int k = scanner.nextInt(); 14 | System.out.print(new Main().getResult(n, k)); 15 | } 16 | 17 | /** 18 | * 递归 19 | * @param n 20 | * @param k 21 | * @return 22 | */ 23 | public int getResult(int n, int k) { 24 | if (n == 1 && k == 1) { 25 | return 0; 26 | } 27 | int middle = 1 << (n - 1); // 2 ^ (n - 1) 28 | if (k == middle) { 29 | return 1; 30 | } else if (k < middle) { 31 | return getResult(n - 1, k); 32 | } else { 33 | k = (middle << 1) - k; 34 | return invert(getResult(n - 1, k)); 35 | } 36 | } 37 | 38 | public int invert(int var) { 39 | return 1 - var; 40 | } 41 | } 42 | ``` -------------------------------------------------------------------------------- /solutions/solution029.md: -------------------------------------------------------------------------------- 1 | # Problem 29 全排列！ 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | 10 | void task29() 11 | { 12 | int num; 13 | std::cin >> num; 14 | int *nums = new int[11]; 15 | for (int iter = 0; iter < num; iter++) 16 | { 17 | nums[iter] = iter + 1; 18 | } 19 | do { 20 | for (int iter = 0; iter < num; iter++) 21 | { 22 | std::cout << nums[iter]; 23 | } 24 | std::cout << std::endl; 25 | } while (std::next_permutation(nums, nums + num)); 26 | return; 27 | } 28 | 29 | 30 | int main() 31 | { 32 | task29(); 33 | return 0; 34 | } 35 | ``` -------------------------------------------------------------------------------- /solutions/solution030.md: -------------------------------------------------------------------------------- 1 | # Problem 30 快乐数列 2 | 3 | ```java 4 | import java.util.Scanner; 5 | 6 | public class Main { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | int n = scanner.nextInt(); 10 | System.out.print(new Main().getResult(n)); 11 | } 12 | 13 | public String getResult(int n) { 14 | if (n == 1) { 15 | return "1"; 16 | } else if (n == 2) { 17 | return "11"; 18 | } 19 | String str = String.valueOf(11); 20 | int prefix = 0, suffix = 0; 21 | int count = 1; 22 | for (int iter = 2; iter < n; iter++) { 23 | String tempStr = ""; 24 | for (int index = 1; index < str.length(); index++) { 25 | prefix = Integer.parseInt(str.substring(index - 1, index)); 26 | suffix = Integer.parseInt(str.substring(index, index + 1)); 27 | if (prefix == suffix) { 28 | count++; 29 | } else { 30 | tempStr += String.valueOf(count) + String.valueOf(prefix); 31 | count = 1; 32 | } 33 | } 34 | prefix = Integer.parseInt(str.substring(str.length() - 1, str.length())); 35 | tempStr += String.valueOf(count) + String.valueOf(prefix); 36 | str = tempStr; 37 | count = 1; 38 | } 39 | return str; 40 | } 41 | } 42 | ``` 43 | -------------------------------------------------------------------------------- /solutions/solution033.md: -------------------------------------------------------------------------------- 1 | # Problem 33 超大数运算 2 | 3 | tag: 快速幂 4 | 5 | ## Solution 6 | 7 | ```java 8 | import java.math.BigInteger; 9 | import java.util.Scanner; 10 | 11 | 12 | /** 13 | * @author ysxiang 14 | */ 15 | 16 | class Main { 17 | public final int MOD = 1337; 18 | 19 | /** 20 | * calculate (a ^ b) mod MOD 21 | * @param a 22 | * @param b 23 | * @return 24 | */ 25 | public long bigPow(int a, String b) { 26 | long ans = 1L; 27 | long base = a; 28 | BigInteger big = new BigInteger(String.valueOf(b)); 29 | while (!big.equals(new BigInteger(String.valueOf(0)))) { 30 | if (big.mod(new BigInteger(String.valueOf(2))).equals(new BigInteger(String.valueOf(1)))) { 31 | ans = ans * base % MOD; 32 | } 33 | base = base * base % MOD; 34 | big = big.divide(new BigInteger(String.valueOf(2))); 35 | } 36 | return ans; 37 | } 38 | 39 | public static void main(String[] args) { 40 | Scanner sc = new Scanner(System.in); 41 | int a = sc.nextInt(); 42 | int n = sc.nextInt(); 43 | StringBuffer b = new StringBuffer(); 44 | for (int i = 0; i < n; i++) { 45 | b.append(sc.next()); 46 | } 47 | System.out.println(new Main().bigPow(a, b.toString())); 48 | } 49 | } 50 | ``` -------------------------------------------------------------------------------- /solutions/solution034.md: -------------------------------------------------------------------------------- 1 | # Problem 34 找特定区间 2 | 3 | ## Solution 4 | 5 | ```java 6 | import java.util.Scanner; 7 | 8 | /** 9 | * @author ysxiang 10 | */ 11 | class Main { 12 | 13 | public int specialSection(int[] nums, int lower, int upper) { 14 | int numsLength = nums.length; 15 | int sectionNumber = 0; // 符合要求区间的个数 16 | int sectionSum = 0; // 区间内的数字和 17 | for (int i = 0; i < numsLength; i++) { 18 | for (int j = i; j < numsLength; j++) { 19 | sectionSum += nums[j]; 20 | if (sectionSum >= lower && sectionSum <= upper) { 21 | sectionNumber++; 22 | } 23 | } 24 | sectionSum = 0; 25 | } 26 | return sectionNumber; 27 | } 28 | 29 | public static void main(String[] args) { 30 | Scanner scanner = new Scanner(System.in); 31 | String str = scanner.nextLine(); 32 | String arr[] = str.split(" "); 33 | int[] nums = new int[arr.length]; 34 | for (int iter = 0; iter < nums.length; iter++) { 35 | nums[iter] = Integer.parseInt(arr[iter]); 36 | } 37 | int lower = scanner.nextInt(); 38 | int upper = scanner.nextInt(); 39 | System.out.println(new Main().specialSection(nums, lower, upper)); 40 | } 41 | } 42 | ``` -------------------------------------------------------------------------------- /solutions/solution035.md: -------------------------------------------------------------------------------- 1 | # Problem 35 数字判断 2 | 3 | ```java 4 | import java.util.Scanner; 5 | import java.util.Vector; 6 | 7 | /** 8 | * @author ysxiang 9 | */ 10 | class Main { 11 | 12 | public static void main(String[] args) { 13 | Scanner scanner = new Scanner(System.in); 14 | int n = scanner.nextInt(); 15 | 16 | System.out.println(new Main().isPowerOfFour(n)); 17 | } 18 | 19 | public boolean isPowerOfFour(int number) { 20 | if (number == 1) { 21 | return true; 22 | } 23 | int result = 4; 24 | for (; result < number; result *= 4) { 25 | 26 | } 27 | if (result == number) { 28 | return true; 29 | } 30 | return false; 31 | } 32 | } 33 | ``` -------------------------------------------------------------------------------- /solutions/solution037.md: -------------------------------------------------------------------------------- 1 | # Problem 37 游乐园中的路径规划 2 | 3 | tag: 动态规划 4 | 5 | ## solution 6 | 7 | ```cpp 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | int cost[50][50]; 14 | int dp[50][50]; 15 | 16 | int min_cost(int m) 17 | { 18 | for (int iter = 0; iter < m; iter++) { 19 | for (int jter = 0; jter < m; jter++) { 20 | if (iter == 0 && jter == 0) { 21 | dp[0][0] = cost[0][0]; 22 | } else if (iter == 0 && jter > 0) { 23 | dp[0][jter] = dp[0][jter - 1] + cost[0][jter]; 24 | } else if (iter > 0 && jter == 0) { 25 | dp[iter][0] = dp[iter - 1][0] + cost[iter][0]; 26 | } else { 27 | dp[iter][jter] = min( 28 | dp[iter - 1][jter] + cost[iter][jter], 29 | dp[iter][jter - 1] + cost[iter][jter]); 30 | } 31 | } 32 | } 33 | return dp[m - 1][m - 1]; 34 | } 35 | 36 | void solution37() 37 | { 38 | int m; 39 | cin >> m; 40 | for (int iter = 0; iter < m; iter++) { 41 | for (int jter = 0; jter < m; jter++) { 42 | cin >> cost[iter][jter]; 43 | } 44 | } 45 | cout << min_cost(m) << endl; 46 | } 47 | 48 | int main() 49 | { 50 | solution37(); 51 | return 0; 52 | } 53 | ``` -------------------------------------------------------------------------------- /solutions/solution041.md: -------------------------------------------------------------------------------- 1 | # Problem 41 收房租 2 | 3 | 慕了，我也想收房租 4 | 5 | tag: Dynamic Programming 6 | 7 | ## Solution 8 | 9 | ```java 10 | import java.util.Scanner; 11 | 12 | /** 13 | * @author ysxiang 14 | */ 15 | 16 | class Main { 17 | public int rob(int[] nums) { 18 | int numsLength = nums.length; 19 | int[] maxMoney = new int[100]; 20 | maxMoney[0] = nums[0]; 21 | maxMoney[1] = nums[1]; 22 | maxMoney[2] = maxMoney[0] + nums[2]; 23 | for (int iter = 3; iter < numsLength; iter++) { 24 | maxMoney[iter] = nums[iter] + Math.max(maxMoney[iter - 2], maxMoney[iter - 3]); 25 | } 26 | return (Math.max(maxMoney[numsLength - 1], maxMoney[numsLength - 2])); 27 | } 28 | 29 | public static void main(String[] args) { 30 | Scanner scanner = new Scanner(System.in); 31 | int n = scanner.nextInt(); 32 | int[] ans = new int[n]; 33 | for (int i = 0; i < n; i++) { 34 | ans[i] = scanner.nextInt(); 35 | } 36 | System.out.println(new Main().bigPow(ans)); 37 | } 38 | } 39 | ``` -------------------------------------------------------------------------------- /solutions/solution043.md: -------------------------------------------------------------------------------- 1 | # Problem 43 找组合数 2 | 3 | tag: 动态规划 4 | 5 | ## solution 6 | 7 | ```cpp 8 | #include 9 | 10 | using namespace std; 11 | 12 | int nums[200]; 13 | int dp[201]; 14 | 15 | // Dynamic Programming 16 | int combination_sum(int nums_length, int target) 17 | { 18 | dp[0] = 1; 19 | for (int iter = 1; iter <= target; iter++) { 20 | for (int index = 0; index < nums_length; index++) { 21 | int num = nums[index]; 22 | if (iter >= num) { 23 | dp[iter] += dp[iter - num]; 24 | } 25 | } 26 | } 27 | return dp[target]; 28 | } 29 | 30 | void solution43() 31 | { 32 | int num, target; 33 | cin >> num; 34 | for (int iter = 0; iter < num; iter++) { 35 | cin >> nums[iter]; 36 | } 37 | cin >> target; 38 | cout << combination_sum(num, target) << endl; 39 | } 40 | 41 | int main() 42 | { 43 | solution43(); 44 | return 0; 45 | } 46 | ``` -------------------------------------------------------------------------------- /solutions/solution045.md: -------------------------------------------------------------------------------- 1 | # Problem 45 找等差数列 2 | 3 | tag: 动态规划 4 | 5 | ## Solution 6 | 7 | ```java 8 | import java.util.Scanner; 9 | 10 | /** 11 | * OJ 12 | * Dynamic Programming 13 | * @author ysxiang 14 | */ 15 | class Main { 16 | public static int longestSubsequence(int[] arr, int difference) { 17 | int arrLength = arr.length; 18 | int[] dp = new int[arrLength]; 19 | int maxLength = 0; 20 | for (int i = 0; i < arrLength; i++) { 21 | for (int j = 0; j < i; j++) { 22 | if (arr[i] - arr[j] == difference) { 23 | dp[i] = dp[j] + 1; 24 | maxLength = Math.max(maxLength, dp[i]); 25 | } 26 | } 27 | } 28 | return maxLength + 1; 29 | } 30 | 31 | public static void main(String[] args) { 32 | Scanner scanner = new Scanner(System.in); 33 | int n = scanner.nextInt(); 34 | int[] arr = new int[n]; 35 | for (int i = 0; i < n; i++) { 36 | arr[i] = scanner.nextInt(); 37 | } 38 | int difference = scanner.nextInt(); 39 | System.out.println(longestSubsequence(arr,difference)); 40 | } 41 | } 42 | ``` -------------------------------------------------------------------------------- /solutions/solution046.md: -------------------------------------------------------------------------------- 1 | # Problem 46 均分数组 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | 8 | using namespace std; 9 | 10 | int nums[100]; 11 | 12 | bool canPartition(int nums_length) 13 | { 14 | int sum = 0; 15 | for (int iter = 0; iter < nums_length; iter++) { 16 | sum += nums[iter]; 17 | } 18 | if ((sum & 1) != 0) { // 若sum为单数 19 | return false; 20 | } 21 | int target = sum >> 1; 22 | bool* dp = new bool[target + 1]; 23 | dp[0] = true; 24 | for (int iter = 0; iter < nums_length; iter++) { 25 | int num = nums[iter]; 26 | if (num > target) { 27 | return false; 28 | } 29 | dp[num] = true; 30 | for (int jter = 0; jter <= target - num; jter++) { 31 | dp[jter + num] = dp[jter] || dp[num]; 32 | } 33 | } 34 | return dp[target]; 35 | } 36 | 37 | void solution46() 38 | { 39 | int nums_length; 40 | cin >> nums_length; 41 | for (int iter = 0; iter < nums_length; iter++) { 42 | cin >> nums[iter]; 43 | } 44 | cout << (canPartition(nums_length) ? "true" : "false") << endl; 45 | } 46 | 47 | int main() 48 | { 49 | solution46(); 50 | return 0; 51 | } 52 | ``` -------------------------------------------------------------------------------- /solutions/solution047.md: -------------------------------------------------------------------------------- 1 | # Problem 47 宝石交易 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | int coins[12]; 12 | 13 | int coinChange(int coins_length, int amount) 14 | { 15 | for (int iter = coins_length - 1; iter >= 0; iter--) { 16 | int coin = coins[iter]; 17 | if (coin > amount) { 18 | continue; 19 | } else if (coin == amount) { 20 | return 1; 21 | } else { 22 | return coinChange(coins_length, amount - coin) + 1; 23 | } 24 | } 25 | cout << -1 << endl; 26 | exit(0); 27 | } 28 | 29 | void solution47() 30 | { 31 | int coins_length, amount; // 宝石个数，总价格 32 | cin >> coins_length; 33 | for (int index = 0; index < coins_length; index++) { 34 | cin >> coins[index]; 35 | } 36 | cin >> amount; 37 | sort(coins, coins + coins_length); 38 | cout << coinChange(coins_length, amount) << endl; 39 | } 40 | 41 | int main() 42 | { 43 | solution47(); 44 | return 0; 45 | } 46 | ``` -------------------------------------------------------------------------------- /solutions/solution048.md: -------------------------------------------------------------------------------- 1 | # Problem 48 寻找乘积最大的连续数 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | int nums[200]; 12 | 13 | int maxProduct(int nums_length) 14 | { 15 | int max_product = 1; 16 | int min_product = 1; 17 | int max_value = 0; 18 | for (int iter = 0; iter < nums_length; iter++) { 19 | if (nums[iter] < 0) { 20 | int temp = max_product; 21 | max_product = min_product; 22 | min_product = temp; 23 | } 24 | max_product = max(max_product * nums[iter], nums[iter]); 25 | min_product = min(min_product * nums[iter], nums[iter]); 26 | max_value = max(max_product, max_value); 27 | } 28 | return max_value; 29 | } 30 | 31 | void solution48() 32 | { 33 | int nums_length; 34 | cin >> nums_length; 35 | for (int iter = 0; iter < nums_length; iter++) { 36 | cin >> nums[iter]; 37 | } 38 | cout << maxProduct(nums_length) << endl; 39 | } 40 | 41 | int main() 42 | { 43 | solution48(); 44 | } 45 | ``` -------------------------------------------------------------------------------- /solutions/solution050.md: -------------------------------------------------------------------------------- 1 | # Problem 50 找特定字符串 2 | 3 | tag: 动态规划 4 | 5 | ## Sample Input 6 | 7 | ```text 8 | abcde 9 | ace 10 | ``` 11 | 12 | > 注意！罗扣上输入样例应该是不包含双引号的！ 13 | > 所有的输入也是不包含双引号的！ 14 | 15 | 16 | ## Sample Output 17 | 18 | ```text 19 | 3 20 | ``` 21 | 22 | ## Solution 23 | 24 | ```cpp 25 | #include 26 | #include 27 | #include 28 | 29 | using namespace std; 30 | 31 | int dp[101][101]; 32 | 33 | // 返回最长公共子序列的个数 34 | // Dynamic Programming 35 | int longest_common_subsequence(string& text1, string& text2) 36 | { 37 | int text1_length = text1.length(); 38 | int text2_length = text2.length(); 39 | for (int iter = 1; iter <= text1_length; iter++) { 40 | for (int jter = 1; jter <= text2_length; jter++) { 41 | if (text1[iter - 1] == text2[jter - 1]) { 42 | dp[iter][jter] = dp[iter - 1][jter - 1] + 1; 43 | } else { 44 | dp[iter][jter] = max( 45 | dp[iter][jter - 1], 46 | dp[iter - 1][jter]); 47 | } 48 | } 49 | } 50 | return dp[text1_length][text2_length]; 51 | } 52 | 53 | void solution50() 54 | { 55 | string text1; 56 | string text2; 57 | cin >> text1 >> text2; 58 | cout << longest_common_subsequence(text1, text2) << endl; 59 | } 60 | 61 | int main() 62 | { 63 | solution50(); 64 | return 0; 65 | } 66 | ``` -------------------------------------------------------------------------------- /solutions/solution051.md: -------------------------------------------------------------------------------- 1 | # Problem 51 采矿 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace std; 11 | 12 | // 背包问题 13 | // 一个矿只能采一次 14 | int maxValue(vector& costs, vector& values, int total_time) 15 | { 16 | int variety_number = costs.size(); // 矿物数量 17 | vector> dp(variety_number + 1, vector(total_time + 1)); 18 | for (int iter = 1; iter <= variety_number; iter++) { 19 | for (int jter = 1; jter <= total_time; jter++) { 20 | if (jter >= costs[iter]) { // 替换出背包里的物品 21 | dp[iter][jter] = max( 22 | dp[iter - 1][jter - costs[iter]] + values[iter], 23 | dp[iter - 1][jter]); 24 | } else { // 按照背包原来的物品 25 | dp[iter][jter] = dp[iter - 1][jter]; 26 | } 27 | } 28 | } 29 | return dp[variety_number][total_time]; 30 | } 31 | 32 | void solution51() 33 | { 34 | int total_time, variety_number; 35 | int cost, value; 36 | 37 | cin >> total_time >> variety_number; 38 | vector costs(variety_number + 1); 39 | vector values(variety_number + 1); 40 | for (int index = 1; index <= variety_number; index++) { 41 | cin >> cost >> value; 42 | costs.push_back(cost); 43 | values.push_back(value); 44 | } 45 | cout << maxValue(costs, values, total_time) << endl; 46 | } 47 | 48 | int main() 49 | { 50 | solution51(); 51 | return 0; 52 | } 53 | ``` -------------------------------------------------------------------------------- /solutions/solution052.md: -------------------------------------------------------------------------------- 1 | # Problem 52 疯狂地采矿 2 | 3 | tag: 完全背包问题 4 | 5 | ## Solution 6 | 7 | ```cpp 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | // 完全背包问题 15 | // 一个矿能采无数次 16 | int maxValue(vector& costs, vector& values, int total_time) 17 | { 18 | int variety_number = costs.size(); // 矿物数量 19 | vector dp(total_time + 1); 20 | for (int iter = 1; iter <= variety_number; iter++) { 21 | for (int jter = costs[iter]; jter <= total_time; jter++) { 22 | dp[jter] = max( 23 | dp[jter - costs[iter]] + values[iter], 24 | dp[jter]); 25 | } 26 | } 27 | return dp[total_time]; 28 | } 29 | 30 | void solution52() 31 | { 32 | int total_time, variety_number; 33 | int cost, value; 34 | 35 | cin >> total_time >> variety_number; 36 | vector costs(variety_number + 1); 37 | vector values(variety_number + 1); 38 | for (int index = 1; index <= variety_number; index++) { 39 | cin >> cost >> value; 40 | costs.push_back(cost); 41 | values.push_back(value); 42 | } 43 | cout << maxValue(costs, values, total_time) << endl; 44 | } 45 | 46 | int main() 47 | { 48 | solution52(); 49 | return 0; 50 | } 51 | ``` -------------------------------------------------------------------------------- /solutions/solution053.md: -------------------------------------------------------------------------------- 1 | # Problem 53 滑板 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int x_direction[4] = { 0, 0, -1, 1 }; 13 | int y_direction[4] = { 1, -1, 0, 0 }; 14 | 15 | // 是否在题目区域内，若在，则返回true 16 | bool inArea(int x, int y, int row_length, int col_length) 17 | { 18 | if ((x >= 0 && y >= 0) && (x < row_length && y < col_length)) { 19 | return true; 20 | } else { 21 | return false; 22 | } 23 | } 24 | 25 | int maxDistance(vector>& matrix, vector>& max_distance, int x, int y) 26 | { 27 | int row_length = matrix.size(); 28 | int col_length = matrix[0].size(); 29 | if (max_distance[x][y] > 0) { 30 | return max_distance[x][y]; 31 | } 32 | max_distance[x][y] = 1; 33 | for (int iter = 0; iter < 4; iter++) { 34 | int to_x = x + x_direction[iter]; 35 | int to_y = y + y_direction[iter]; 36 | if (inArea(to_x, to_y, row_length, col_length) && matrix[x][y] > matrix[to_x][to_y]) { 37 | max_distance[x][y] = max( 38 | maxDistance(matrix, max_distance, to_x, to_y) + 1, 39 | max_distance[x][y]); 40 | } 41 | } 42 | return max_distance[x][y]; 43 | } 44 | 45 | void solution53() 46 | { 47 | int row, col; 48 | int max_dis = 0; 49 | cin >> row >> col; 50 | vector> matrix(row, vector(col)); 51 | vector> max_distance(row, vector(col)); // 判断是否经历过这个点 52 | for (int iter = 0; iter < row; iter++) { 53 | for (int jter = 0; jter < col; jter++) { 54 | cin >> matrix[iter][jter]; 55 | } 56 | } 57 | 58 | for (int iter = 0; iter < row; iter++) { 59 | for (int jter = 0; jter < col; jter++) { 60 | max_dis = max( 61 | maxDistance(matrix, max_distance, iter, jter), 62 | max_dis); 63 | } 64 | } 65 | cout << max_dis << endl; 66 | } 67 | 68 | int main() 69 | { 70 | solution53(); 71 | return 0; 72 | } 73 | ``` -------------------------------------------------------------------------------- /solutions/solution061.md: -------------------------------------------------------------------------------- 1 | # Problem 61 最大增序长度 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int maxIncreaseLength(vector& nums) 12 | { 13 | int nums_length = nums.size(); 14 | int max_increase_length = 0; 15 | vector dp(nums_length); 16 | for (int iter = 0; iter < nums_length; iter++) { 17 | for (int jter = 0; jter < iter; jter++) { 18 | if (nums[jter] < nums[iter]) { 19 | dp[iter] = max(dp[jter] + 1, dp[iter]); 20 | } 21 | } 22 | max_increase_length = max(dp[iter], max_increase_length); 23 | } 24 | return max_increase_length + 1; 25 | } 26 | 27 | void solution61() 28 | { 29 | int nums_length; 30 | cin >> nums_length; 31 | vector nums(nums_length); 32 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 33 | cin >> *(iter); 34 | } 35 | cout << maxIncreaseLength(nums) << endl; 36 | } 37 | 38 | int main() 39 | { 40 | solution61(); 41 | return 0; 42 | } 43 | ``` -------------------------------------------------------------------------------- /solutions/solution062.md: -------------------------------------------------------------------------------- 1 | # Problem 62 花样二叉树 2 | 3 | 4 | ## Solution 5 | 6 | ```cpp 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int BST_number(int num) 12 | { 13 | vector kinds_number(num + 1); 14 | kinds_number[0] = 1; 15 | for (int iter = 1; iter <= num; iter++) { 16 | int kind_number = 0; 17 | for (int jter = 0; jter < iter; jter++) { // 对于有num个节点的BST，其BST的个数 == 左子树(i个节点)的个数 * 右子树(n - i - 1个节点)的个数 18 | kind_number += kinds_number[jter] * kinds_number[iter - jter - 1]; 19 | } 20 | kinds_number[iter] = kind_number; 21 | } 22 | return kinds_number[num]; 23 | } 24 | 25 | void solution62() 26 | { 27 | int num; 28 | cin >> num; 29 | cout << BST_number(num) << endl; 30 | } 31 | 32 | int main() 33 | { 34 | solution62(); 35 | return 0; 36 | } 37 | ``` -------------------------------------------------------------------------------- /solutions/solution066.md: -------------------------------------------------------------------------------- 1 | # Problem 66 最大接雨水量 2 | 3 | # Solution 4 | 5 | ```java 6 | import java.util.Scanner; 7 | import java.util.Vector; 8 | 9 | /** 10 | * @author ysxiang 11 | */ 12 | class Main { 13 | 14 | public static void main(String[] args) { 15 | Scanner scanner = new Scanner(System.in); 16 | int n = scanner.nextInt(); 17 | Vector heights = new Vector(); 18 | for (int iter = 0; iter < n; iter++) { 19 | heights.add(scanner.nextInt()); 20 | } 21 | System.out.println(new Main().isPowerOfFour(heights)); 22 | } 23 | 24 | public int solution(Vector heights) { 25 | int length = heights.size(); 26 | int maxVolume = 0; 27 | for (int frontFlag = 0; frontFlag < length - 1; frontFlag++) { 28 | for (int backFlag = frontFlag + 1; backFlag < length; backFlag++) { 29 | int minHeight = 30 | heights.get(frontFlag) < heights.get(backFlag) ? 31 | heights.get(frontFlag) : heights.get(backFlag); 32 | int volume = minHeight * (backFlag - frontFlag); 33 | maxVolume = volume > maxVolume ? volume : maxVolume; 34 | } 35 | } 36 | return maxVolume; 37 | } 38 | } 39 | ``` -------------------------------------------------------------------------------- /solutions/solution069.md: -------------------------------------------------------------------------------- 1 | # Problem 69 摇摆序列 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int maxSwingLength(vector& nums) 12 | { 13 | int nums_length = nums.size(); 14 | int up = 1, down = 1; 15 | for (int iter = 1; iter < nums_length; iter++) { 16 | if (nums[iter] > nums[iter - 1]) { 17 | up = down + 1; 18 | } 19 | if (nums[iter] < nums[iter - 1]) { 20 | down = up + 1; 21 | } 22 | } 23 | return max(up, down); 24 | } 25 | 26 | void solution69() 27 | { 28 | int nums_length; 29 | cin >> nums_length; 30 | vector nums(nums_length); 31 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 32 | cin >> *(iter); 33 | } 34 | cout << maxSwingLength(nums) << endl; 35 | } 36 | 37 | int main() 38 | { 39 | solution69(); 40 | return 0; 41 | } 42 | ``` -------------------------------------------------------------------------------- /solutions/solution070.md: -------------------------------------------------------------------------------- 1 | # Problem 70 拆分成对 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int splitIntoPairs(vector& nums) 12 | { 13 | int min_sum = 0; 14 | sort(nums.begin(), nums.end()); 15 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 16 | min_sum += *(iter++); 17 | } 18 | return min_sum; 19 | } 20 | 21 | void solution70() 22 | { 23 | int nums_length; 24 | cin >> nums_length; 25 | vector nums(nums_length); 26 | for (auto iter = nums.begin(); iter < nums.end(); iter++) { 27 | cin >> *(iter); 28 | } 29 | cout << splitIntoPairs(nums) << endl; 30 | } 31 | 32 | int main() 33 | { 34 | solution70(); 35 | return 0; 36 | } 37 | ``` -------------------------------------------------------------------------------- /solutions/solution071.md: -------------------------------------------------------------------------------- 1 | # Problem 71 羊群的合并 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int mergeSheep(priority_queue, greater>& sheep_queue) 12 | { 13 | int sheep1, sheep2; 14 | int sum = 0; 15 | while (sheep_queue.size() > 1) { 16 | sheep1 = sheep_queue.top(); 17 | sheep_queue.pop(); 18 | sheep2 = sheep_queue.top(); 19 | sheep_queue.pop(); 20 | sum += sheep1 + sheep2; 21 | sheep_queue.push(sheep1 + sheep2); 22 | } 23 | return sum; 24 | } 25 | 26 | void solution71() 27 | { 28 | int sheep_queue_length; 29 | cin >> sheep_queue_length; 30 | priority_queue, greater> sheep_queue; // 优先队列，从小到大 31 | for (int iter = 0; iter < sheep_queue_length; iter++) { 32 | int sheep_number; 33 | cin >> sheep_number; 34 | sheep_queue.push(sheep_number); 35 | } 36 | cout << mergeSheep(sheep_queue) << endl; 37 | } 38 | 39 | int main() 40 | { 41 | solution71(); 42 | return 0; 43 | } 44 | ``` -------------------------------------------------------------------------------- /solutions/solution072.md: -------------------------------------------------------------------------------- 1 | # Problem 72 买到所有玩具 2 | 3 | 4 | 5 | ## Solution 6 | 7 | ```cpp 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int minCost(vector& toy_prices) 14 | { 15 | int toy_prices_length = toy_prices.size(); 16 | int total_price = 0; 17 | sort(toy_prices.begin(), toy_prices.end()); 18 | for (int iter = toy_prices_length - 1; iter >= 1; iter -= 3) { 19 | total_price += toy_prices[iter] + toy_prices[iter - 1]; 20 | } 21 | if (toy_prices_length % 3 == 1) { 22 | total_price += toy_prices[0]; 23 | } 24 | return total_price; 25 | } 26 | 27 | void solution72() 28 | { 29 | int toy_number; 30 | cin >> toy_number; 31 | vector toy_prices(toy_number); 32 | for (vector::iterator it = toy_prices.begin(); it < toy_prices.end(); it++) { 33 | cin >> *it; 34 | } 35 | cout << minCost(toy_prices) << endl; 36 | } 37 | 38 | int main() 39 | { 40 | solution72(); 41 | return 0; 42 | } 43 | ``` -------------------------------------------------------------------------------- /solutions/solution100.md: -------------------------------------------------------------------------------- 1 | # Problem 100 凑数的题 2 | 3 | ## Solution 4 | 5 | ```cpp 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | static constexpr int TARGET = 24; 12 | static constexpr double EPSILON = 1e-6; 13 | static constexpr int ADD = 0, MULTIPLY = 1, SUBTRACT = 2, DIVIDE = 3; 14 | 15 | bool solve(vector& nums) 16 | { 17 | if (nums.size() == 0) { 18 | return false; 19 | } 20 | if (nums.size() == 1) { 21 | return fabs(nums[0] - TARGET) < EPSILON; 22 | } 23 | int nums_length = nums.size(); 24 | for (int iter = 0; iter < nums_length; iter++) { 25 | for (int jter = 0; jter < nums_length; jter++) { 26 | if (iter != jter) { 27 | vector list2; 28 | for (int kter = 0; kter < nums_length; kter++) { 29 | if (kter != iter && kter != jter) { 30 | list2.emplace_back(nums[kter]); 31 | } 32 | } 33 | for (int kter = 0; kter < 4; kter++) { 34 | if (kter < 2 && iter > jter) { 35 | continue; 36 | } 37 | switch (kter) { 38 | case ADD: 39 | list2.emplace_back(nums[iter] + nums[jter]); 40 | break; 41 | case MULTIPLY: 42 | list2.emplace_back(nums[iter] * nums[jter]); 43 | break; 44 | case SUBTRACT: 45 | list2.emplace_back(nums[iter] - nums[jter]); 46 | break; 47 | case DIVIDE: 48 | if (fabs(nums[jter]) < EPSILON) { 49 | continue; 50 | } 51 | list2.emplace_back(nums[iter] / nums[jter]); 52 | break; 53 | default: 54 | break; 55 | } 56 | if (solve(list2)) { 57 | return true; 58 | } 59 | list2.pop_back(); 60 | } 61 | } 62 | } 63 | } 64 | return false; 65 | } 66 | 67 | bool judgePoint24(vector& nums) 68 | { 69 | vector double_nums; 70 | for (const int& num : nums) { 71 | double_nums.emplace_back(static_cast(num)); 72 | } 73 | return solve(double_nums); 74 | } 75 | 76 | void solution100() 77 | { 78 | vector nums(4); 79 | for (vector::iterator iter = nums.begin(); iter < nums.end(); iter++) { 80 | cin >> *(iter); 81 | } 82 | cout << (judgePoint24(nums) ? "true" : "false") << endl; 83 | } 84 | 85 | int main() 86 | { 87 | solution100(); 88 | return 0; 89 | } 90 | ``` -------------------------------------------------------------------------------- /spider.py: -------------------------------------------------------------------------------- 1 | """ 2 | 爬取自己OJ通过的代码 3 | """ 4 | import requests 5 | import os 6 | 7 | os.makedirs("code-set", exist_ok=True) 8 | headers = { 9 | "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36"} 10 | data = { 11 | "username": "2020302877+项裕顺", # 填写用户名 12 | "password": "237012.xys1234" # 填写密码 13 | } 14 | init_url = "http://10.216.217.131:9999/api/profile" 15 | login_url = "http://10.216.217.131:9999/api/login" 16 | problems_url = "http://10.216.217.131:9999/api/contest/problem?contest_id=3" 17 | submission_url = "http://10.216.217.131:9999/api/contest_submissions" 18 | code_url = "http://10.216.217.131:9999/api/submission" 19 | submission_params = { 20 | "myself": 1, 21 | "result": None, 22 | "username": None, 23 | "page": 1, 24 | "contest_id": 3, 25 | "limit": 12, 26 | "offset": 0 27 | } 28 | language_suffix = { 29 | "C": ".c", 30 | "C++": ".cpp", 31 | "Java": ".java", 32 | "Python3": ".py", 33 | "Python2": ".py", 34 | "Golang": ".go" 35 | } 36 | session = requests.Session() 37 | session.headers["User-Agent"] = headers["User-Agent"] 38 | session.get(url=init_url) 39 | session.headers["X-CSRFToken"] = session.cookies.get("csrftoken") 40 | session.post(url=login_url, data=data) 41 | problems = session.get(url=problems_url).json() 42 | for problem in problems["data"]: 43 | if problem["my_status"] == 0: 44 | submissions = session.get(submission_url, params={**submission_params, "problem_id": problem["_id"]}).json() 45 | for submission in submissions["data"]["results"]: 46 | if submission["result"] == 0: 47 | subcode = session.get(code_url, params={"id": submission["id"]}).json()["data"] 48 | with open("code-set/" + subcode["problem"] + language_suffix[subcode["language"]], "w") as f: 49 | f.write(subcode["code"]) 50 | break 51 | --------------------------------------------------------------------------------