目录
【案例1】
【题目描述】
【思路解析】
【代码实现】
【案例2】
【题目描述】
【思路解析】
【代码实现】
【案例3】
【题目描述】
【思路解析】
【案例4】
【题目描述】
【思路解析】
【代码实现】
【案例5】
【题目描述】
【子序列概念】
【思路解析1 经典方法 时间复杂度为O(N^2)】
【代码实现1】
【思路解析2 优化技巧之构建单调性 时间复杂度为O(N*logN)】
【代码实现2】
【案例6】
【题目描述】
【思路解析】
【代码实现】
【案例1】
【题目描述】
【思路解析】
一个简单的贪心策略。
对于字符串str，任意一个位置上只能为字符'.'或者'X'。则对于任意i位置有两种情况。
（1）i位置上为字符'X'，此位置不需要放路灯
（2）i位置上为字符'.'，此位置放灯则需要根据i+1位置来判断，如果i+1位置是‘X'，则i位置放灯，如果i+1位置是’.'，则i+1位置放灯。
【代码实现】
import java.util.Scanner;
/**
* @ProjectName: study3
* @FileName: Ex1
* @author:HWJ
* @Data: 2023/7/30 9:27
*/
public class Ex1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int t = input.nextInt();
for (int i = 0; i < t; i++) {
int n = input.nextInt();
String s = input.nextLine();
System.out.println(minLight(s, n));
}
}
public static int minLight(String s, int length) {
if (s == null || length == 0) {
return 0;
}
char[] str = s.toCharArray();
int i = 0;
int count = 0;
while (i < length) {
if (str[i] == 'X') {
i++;
} else {
count++;
// 加入条件(i + 1) < length 来防止越界
if ((i + 1) < length && str[i + 1] == 'X') {
i += 2;
} else if ((i + 1) < length && str[i + 1] == '.') {
i += 3;
}else { // 如果不是以上两种情况 就说明 i+1 == length，说明已经遍历完成，直接退出循环
break;
}
}
}
return count;
}
}【案例2】
【题目描述】
【思路解析】
我们已知先序数组int[ ] pre，中序数组int[ ] in，我们需要得到后序数组int[ ] pos，先序数组和中序数组和后序数组长度相同，然后先序数组对应二叉树的顺序为头左右，中序数组对应二叉树的顺序为左头右，后序数组对应二叉树的顺序为左右头，所以我们可以通过先序数组的第一个位置确定整棵树的头，然后找出它在中序数组的位置，此位置左边就是整棵树最大的左子树，右边就是整棵树最大的右子树，然后在先序数组中头位置的右边同样多的数也是左子树，然后剩下的数为右子树，这样又可以继续递归确定子树的位置然后将其填入后序数组中。填入时，头位置填入在当前填充后序数组位置中最后一个，然后填入右子树，然后填入左子树，填入顺序为从右至左。
【代码实现】
代码中在中序数组中寻找头的位置使用的是遍历的方式，我们可以对中序数组中每个位置上的值做一个哈希表来对应，这样下次寻找头的时候直接访问哈希表即可，创建哈希表只需要做一次遍历，所以这是一个优化搜索的方法。
import java.util.Arrays;
/**
* @ProjectName: study3
* @FileName: Ex2
* @author:HWJ
* @Data: 2023/7/30 10:16
*/
public class Ex2 {
public static void main(String[] args) {
int[] pre = {1,2,4,5,3,6,7};
int[] in = {4,2,5,1,6,3,7};
int[] pos = getPosArray(pre, in);
System.out.println(Arrays.toString(pos));
}
public static int[] getPosArray(int[] pre,int[] in){
int N = pre.length;
int[] pos = new int[N];
process(pre, 0, N - 1, in, 0, N - 1, pos, 0, N - 1);
return pos;
}
public static void process(int[] pre, int prei, int prej,
int[] in, int ini, int inj,
int[] pos, int posi, int posj){
if (prei > prej){
return;
}
pos[posj] = pre[prei];
int find = ini;
for (; find < inj; find++) {
if (in[find] == pre[prei]){
break;
}
}
process(pre, prei + 1 + find - ini, prej, in, find + 1, inj, pos, posj - (find - ini), posj - 1);
process(pre, prei + 1, prei + find - ini, in, ini, find - 1, pos, posi, posi - 1 + (find - ini));
}
}
【案例3】
【题目描述】
将一个数字用中文表示出来，表示规则需要满足中国人的读数习惯。
经考查 15中国人习惯读十五，215习惯读二百一十五（个别省份读两百一十五），1017习惯读一千零十七，1215习惯读一千二百一十五，所以十位前读不读1，取决于有没有百位。
【思路解析】
纯coding问题，但是有一个策略，可以先完成1-10的发言，再完成1-99，在完成1-999，后面依次累加，完成全部。
【案例4】
【题目描述】
【思路解析】
如果使用遍历的话完全能得到个数，但时间复杂度为O(N)，所以我们需要利用完全二叉树的特性来进行优化，时间复杂度可以达到O((logN)^2)。
【代码实现】
/**
* @ProjectName: study3
* @FileName: Ex4
* @author:HWJ
* @Data: 2023/7/30 11:17
*/
public class Ex4 {
public static void main(String[] args) {
}
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int value) {
this.value = value;
}
}
// 请保证以head为头的树是一颗完全二叉树。
public static int nodeNum(Node head) {
if (head == null) {
return 0;
}
return bs(head, 1, mostLeftLevel(head, 1));
}
// level 表示node节点所在层数， h表示整棵树的深度
public static int bs(Node node, int level, int h) {
if (level == h) {
return 1;
}
if (mostLeftLevel(node.right, level + 1) == h) {
// 如果mostLeftLevel(node.right, level + 1) == h，即右子树的最左节点到了h层说明左子树一定是一个满二叉树。
// 否则说明右子树是一个满二叉树。
return (1 << (h - level)) + bs(node.right, level + 1, h);
} else {
return (1 << (h - level - 1)) + bs(node.left, level + 1, h);
}
}
// 求出此节点在这棵树上的最左节点的层数
// L表示node在的层数
// 以node为节点的整棵树应该满足完全二叉树的定义
public static int mostLeftLevel(Node node, int L) {
while (node.left != null) {
L++;
node = node.left;
}
return L;
}
}
【案例5】
【题目描述】
【子序列概念】
子序列是指一个序列中任意选取若干个元素（可以是相邻的元素，也可以是不相邻的元素）组成的序列。这些元素的原先相对顺序保持不变。例如，对于序列 [1, 2, 3, 4]，其子序列可以是 [1, 2, 3]、[1, 4]、[2, 4]、[1, 3, 4] 等等。在算法和数据结构中，子序列广泛用于字符串匹配、最长子序列等问题的求解。
【思路解析1 经典方法 时间复杂度为O(N^2)】
生成一个与数组arr等长的数组dp,dp[i]的含义为以arr[i[为结尾的子序列最长长度为多少。这样对于任意位置i，它前面的位置已经形成了它的最长递增子序列，然后我们以i位置的数字结尾，我们只需要找到0 --- i-1位置上小于i位置数字的最优解作为倒数第二个数字即可（如果找不到这样的第二个数字，这dp[i]填充1），这样就可以完成对dp数组的填充。然后找出dp数组中最大的那个，我们便得到了最长递增子序列的长度。
【代码实现1】
/**
* @ProjectName: study3
* @FileName: Ex5
* @author:HWJ
* @Data: 2023/7/30 12:58
*/
public class Ex5 {
public static void main(String[] args) {
int[] arr = {6, 1, 5, 2, 7, 3, 4};
System.out.println(getMaxSub(arr));
}
public static int getMaxSub(int[] arr) {
int N = arr.length;
int[] dp = new int[N];
for (int i = 0; i < N; i++) {
dp[i] = 1; //初始化为1，不管后面是否能找到，都能得到正确的dp结果
for (int j = i - 1; j >= 0; j--) {
if (arr[i] > arr[j]) { // 找到0 --- i-1位置上小于i位置数字的最优解作为倒数第二个数字
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
}
int max = dp[0];
for (int i = 1; i < N; i++) {
max = Math.max(max, dp[i]);
}
return max;
}
}
【思路解析2 优化技巧之构建单调性 时间复杂度为O(N*logN)】
构建一个等长的ends数组，刚开始里面数据全是无效区域，然后遍历arr数组每个数字，然后在ends数字的有效区域中找到大于这个数字的最左位置，然后更新这个位置上的数字，如果找不到这个数字，则扩充有效区域，然后将这个数字更新到有效区域上，因为这个数组满足单调性，所以在ends数组遍历时可以使用二分法，使遍历的时间复杂度为O(logN)。然后确定了这个数字的在ends上的所在位置后如果该位置假设为i位置，则以它为结尾的最长递增子序列的长度为i+1。
但是如果我们只需要得到最长递增子序列的长度，而不需要知道以arr每个数字结尾的最长递增子序列的长度，我们便可以不再构造dp数组，而是将ends的有效区域长度作为最优解返回。
即代码2的返回修改为 return right + 1；
【代码实现2】
/**
* @ProjectName: study3
* @FileName: Ex6
* @author:HWJ
* @Data: 2023/7/30 13:15
*/
public class Ex6 {
public static void main(String[] args) {
int[] arr = {6, 1, 5, 2, 7, 3, 4};
System.out.println(getMaxSub(arr));
}
public static int getMaxSub(int[] arr) {
int N = arr.length;
int[] dp = new int[N];
int[] ends = new int[N];
int left = 0;
int right = 0;
ends[0] = arr[0];
dp[0] = 1;
for (int i = 1; i < N; i++) {
int index = getIndex(ends, left, right, arr[i]);
if (index == -1){
ends[++right] = arr[i];
dp[i] = right + 1;
}else {
ends[index] = arr[i];
dp[i] = index + 1;
}
}
int max = Integer.MIN_VALUE;
for (int i = 0; i < N; i++) {
max = Math.max(dp[i], max);
}
return max;
}
// 这里的left和right与上面的left和right同义，代表ends数组的有效区域，范围为[left,right]
// 返回ends数组中，大于num的最左数字的索引
// 如果返回的索引为-1，则没有找到比num大的数字，则需要扩充ends数组的有效区域，然后更新数组，否则直接根据索引进行更新
public static int getIndex(int[] ends, int left, int right, int num){
int index = -1;
while(left <= right){
int mid = (left + right) / 2;
if (ends[mid] > num){
right = mid - 1;
index = mid;
}else {
left = mid + 1;
}
}
return index;
}
}
【案例6】
【题目描述】
【思路解析】
如果n=13，则这个数字为12345678910111213，然后他能不能被3整除可以转化为（1+2+3+4+5+6+7+8+9+1+0+1+1+1+2+1+3）能不能被3整除，然后10能不能被3整除又可以转化为1+0能不能被3整除，所以我们可以将（1+2+3+4+5+6+7+8+9+1+0+1+1+1+2+1+3）这里的数字作同语替换改为（1+2+3+4+5+6+7+8+9+10+11+12+13），这就可以转为 ((n * (n+1))/2)%3，然后防止((n * (n+1))/2)过大，所以使用long来存放
【代码实现】
import java.util.Scanner;
/**
* @ProjectName: study3
* @FileName: Ex7
* @author:HWJ
* @Data: 2023/7/30 14:00
*/
public class Ex7 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int l =input.nextInt();
int r = input.nextInt();
int count = 0;
for (int i = l; i <= r; i++) {
long s = ((long) (i + 1) * i) / 2;
if (s % 3 == 0){
count++;
}
}
System.out.println(count);
}
}
