《 挑战程序设计竞赛 》简要笔记

第一章

三角形

有N根棍子，棍子第i的长度为Ai，想要从中选出三根棍子组成周长尽可能长的三角形，请输出最大的周长，若无法组成，请输出0。（数组有序）

• 若存在结果，则三根长度定相邻。

public class Main {
    public static int process(int[] arr) {
        int res = 0;
        for (int i = 0; i <= arr.length - 3; i++) {
            if (arr[i] + arr[i + 1] > arr[i + 2] && arr[i + 2] - arr[i + 1] < arr[i]) {
                res = Math.max(res, arr[i] + arr[i + 1] + arr[i + 2]);
            }
        }
        return res;
    }
}

INTS

M只蚂蚁以每秒一厘米的速度在长为N的杆子上爬行，当蚂蚁爬到杆子的端点是会自动掉落，由于杆子太细，两只蚂蚁相遇时，他们不能交错通过，只能各自反向爬回去，对于每只蚂蚁，我们知道它的距离，杆子左端的距离，X2，但不知道它向前的朝向，请计算所有蚂蚁下落的杆子所需要的最短时间和最长时间。

• 无视蚂蚁的区别相遇后认为保持原样交错而过。

public class Main {
    public static int[] process(int[] arr, int N) {
        int min = Integer.MAX_VALUE, max = 0;
        for (int value : arr) {
            min = Math.min(min, Math.min(value, N - value));
            max = Math.max(max, Math.max(value, N - value));
        }
        return new int[]{min, max};
    }
}

第二章

广搜迷宫

给定数组maze，. 表示通路，给定起始点和结束点横纵坐标，返回从起始点到终点的最近距离。

public class Main {
    static int[] dx = {1, 0, -1, 0};
    static int[] dy = {0, 1, 0, -1};

    public static int process(int[][] maze, int startX, int startY, int endX, int endY) {
        int M = maze.length;
        int N = maze[0].length;
        int[][] lenMaze = new int[N][M];
        for (int i = 0; i < M; i++) {
            Arrays.fill(lenMaze[i], Integer.MAX_VALUE);
        }
        ArrayDeque<Node> deque = new ArrayDeque<>();
        deque.push(new Node(startX, startY));
        lenMaze[startX][startY] = 0;
        while (!deque.isEmpty()) {
            Node node = deque.poll();
            if (node.x == startX && node.y == startY) {
                break;
            }
            for (int i = 0; i < 4; i++) {
                Node n = new Node(node.x + dx[i], node.y + dy[i]);
                if (n.x >= 0 && n.x < M && n.y >= 0 && n.y < N && lenMaze[n.x][n.y] == Integer.MAX_VALUE && maze[n.x][n.y] == '.') {
                    deque.push(n);
                    lenMaze[n.x][n.y] = lenMaze[node.x][node.y] + 1;
                }
            }
        }
        return lenMaze[endX][endY];
    }

    static class Node {
        int x;
        int y;

        Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

Saruman’s Army

直线上有N个点,点i 的位置为Xi，从这N个点中，选择若干个给他们加上标记，对于每一个点其距离为R的距离，区域内必须有带标记的点，自身带有标记的点，可以认为与其距离为0的地方有一个带有标记的点，在满足这个条件的情况下，希望能为尽可能少的点添加标记，请问至少要添加多少被标记的点。

public class Main {
    public static int process(int[] arr, int R) {
        int num = 0, i = 0;
        while (i < arr.length) {
            int s = arr[i++];
            while (i < arr.length && arr[i] <= s + R) i++;
            int mid = arr[i - 1];
            while (i < arr.length && arr[i] <= mid + R) i++;
            num++;
        }
        return num;
    }
}

背包问题

经典01

public class Main {
    public static int process(int[] weights, int[] values, int maxBag) {
        int[][] dp = new int[weights.length + 1][maxBag + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int j = 0; j <= maxBag; i++) {
                if (j < weights[i]) {
                    dp[i + 1][j] = dp[i][j];
                } else {
                    dp[i + 1][j] = Math.max(dp[i][j], dp[i][j - weights[i]] + values[i]);
                }
            }
        }
        return dp[weights.length][maxBag];
    }
}

空间压缩01正填

public class Main {
    public static int process(int[] weights, int[] values, int maxBag) {
        int[][] dp = new int[2][maxBag + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int j = 0; j <= maxBag; j++) {
                if (j < weights[i]) {
                    dp[(i + 1) & 1][j] = dp[i & 1][j];
                } else {
                    dp[(i + 1)][j] = Math.max(dp[i & 1][j], dp[i & 1][j - weights[i]] + values[i]);
                }
            }
        }
        return dp[weights.length&1][maxBag];
    }
}

空间压缩01反填

public class Main {
    public static int process(int[] weights, int[] values, int maxBag) {
        int[] dp = new int[maxBag + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int j = maxBag; j >= weights[i]; j++) {
                dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
            }
        }
        return dp[maxBag];
    }
}

经典完全

public class Main {
    public static int process(int[] weights, int[] values, int maxBag) {
        int[][] dp = new int[weights.length + 1][maxBag + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int j = 0; j <= maxBag; j++) {
                for (int k = 0; k * weights[i] <= j; k++) {
                    dp[i + 1][j] = Math.max(dp[i + 1][j], dp[i][j - weights[i] * k] + weights[i] * k);
                }
            }
        }
        return dp[weights.length][maxBag];
    }
}

压缩完全背包

public class Main {
    public static int process(int[] weights, int[] values, int maxBag) {
        int[] dp = new int[maxBag + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int j = weights[i]; j <=maxBag; j++) {
                dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
            }
        }
        return dp[maxBag];
    }
}

最长上升子序列

动态规划

public class Main {
    public static int process(int[] arr) {
        int[] dp = new int[arr.length];
        int res = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                dp[i] = 1;
                if (dp[j] < dp[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

最优解

public class Main {
	/**
	 * 之前我们取的是直接存储某位置之前所存在的最长序列的个数，时间复杂度为O(N^2)
	 * 该种方法，我们可以了解到，当前面的值有存在序列最长值大于等于其他值，并且该值较小
	 * 那么比该值大且前面的子序列个数还较少，这些值就不可能成为我们的最终选的结果。
	 * 
	 * 我们现在选择一种方式，就是抛弃上述过程中存在的这些值，用下标位置索引表示当前的子序列长度。复杂度O(N*logN)
	 * 就像indexIsMaxNumArr[maxNumIndex]表示：
	 * 前面存在最长子序列长度为maxNumIndex时，满足该条件下的最小值为indexIsMaxNumArr[maxNumIndex]
	 */
	public static int process(int[] arr) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		int[] indexIsMaxNumArr = new int[arr.length];
		int maxNumIndex = -1;// 存在最长长度索引
		for (int value : arr) {
			if (maxNumIndex == -1 || indexIsMaxNumArr[maxNumIndex] < value) {
				// 之前不存在值或者该值大于之前所有值，此时肯定比之前最长索引大1，所以maxNumIndex加上1
				indexIsMaxNumArr[++maxNumIndex] = value;
			} else {
				// 查找indexIsMaxNumArr[0…………maxNumIndex]范围中，值大于或等于value的最小值索引。
				int index = biggerThanValueLeftestIndex(indexIsMaxNumArr, value, maxNumIndex);
				// 更新该值
				indexIsMaxNumArr[index] = value;
			}
		}
		return maxNumIndex + 1;
	}

	/**
	 * 该函数在查找时总结过
	 * 
	 * @param indexIsMaxNumArr 数组
	 * @param value            目标值
	 * @param right            右端索引
	 * @return 值大于或等于value的最小值索引
	 */
	private static int biggerThanValueLeftestIndex(int[] indexIsMaxNumArr, int value, int right) {
		int left = 0;
		while (left < right) {
			int med = ((right - left) >> 1) + left;
			if (indexIsMaxNumArr[med] == value) {
				return med;
			} else if (indexIsMaxNumArr[med] > value) {
				right = med;
			} else {
				left = med + 1;
			}
		}
		return right;
	}
}

Expedition

你需要驾驶一辆卡车，行驶L单位距离，最开始时，卡车上有一个P单位的汽油，每开一单位长度距离需要消耗一单位的汽油，如果在途中上汽油的汽油消耗完卡车就无法继续前行，因而无法到达终点，在途中一共有N个加油站，第i个加油站在是locations[ i ]单位距离的地方，最多可以给卡车加num[ i ]单位汽油,假设卡车的燃料箱无限大，装多少油都没有问题，那么请问卡车是否能达到终点？如果可以的用点输出最少加油次数，否则输出-1。

public class Main {
    public static int process(int[] locations, int[] num, int P, int L) {
        int thisL = P;
        PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o2-o1);
        int index = 0, res = 0;
        while (thisL < L) {
            while (index < locations.length && locations[index] <= thisL) {
                queue.add(num[index++]);
            }
            if (queue.isEmpty()) return -1;
            thisL += queue.poll();
            res++;
        }
        return res;
    }
}