题目1
给定一个有序数组arr，给定一个正数aim
(1)返回累加和为aim的，所有不同二元组
(2)返回累加和为aim的，所有不同三元组
问题一
暴力的解法就是 遍历每一个二元组 找和为aim的
当然 只用暴力解很难ac 想一想有序 那肯定就是能加速 我们可以选择 先抓住一个数 然后另一个数用二分查找 确实把复杂度从O(N²)缩小到 O(N*logN)
解题的时候还想过用单调栈或者滑动窗口 不过这个答案又不一定是连续的 只能作罢
预处理累加数组 也不能加速查找
更好的做法是 双指针法 左右指针分别放在0位置和N-1位置 那么是有序的数组 所以可以让左指针右移让整体和增加 右指针左移 让整体和减少 复杂度为O(N)
捋一下做法
(1)当sum<aim 左指针右移
(2)sum>aim 右指针左移
(3)sum == aim 左指针右移和左指针右移都可以 本质上来讲就是换一种尝试
public static void selectTwo(int [] arr,int aim) {
int left = 0;
int right = arr.length-1;
int sum = 0;
while(left<=right-1) {
sum = arr[left] + arr[right];
if(sum<aim) {
left++;
}
if(sum>aim) {
right--;
}
if(sum==aim) {
System.out.println(arr[left]+" "+arr[right]);
left++;
}
}
}问题二
简单 先以选定每一个数为 三元组中第一个数 然后转化为二元问题
public static void selectTwo(int [] arr,int aim,int i,int index) {
int left = i;
int right = arr.length-1;
int sum = 0;
while(left<=right-1) {
sum = arr[left] + arr[right];
if(sum<aim) {
left++;
}
if(sum>aim) {
right--;
}
if(sum==aim) {
System.out.println(index+" "+arr[left]+" "+arr[right]);
left++;
}
}
}
private static void selectThree(int [] arr,int aim) {
for(int i = 0;i<=arr.length-1;i++) {
selectTwo(arr, aim-arr[i],i,arr[i]);
}
题目二
问题一
给定一个数组arr，已知其中所有的值都是非负的，将这个数组看作一个容器，请返回容器能装多少水比如，arr={3,1,2,5,2,4)，根据值画出的直方图就是容器形状，该容器可以装下5格水再比如，arr={4,5,1,3,2}，该容器可以装下2格水
遍历每一个位置可以装多少水 当前位置的装水数就是 左侧的最大值和右侧的最大值取最小值 再减去当前高度 然后如果是负数就不考虑(这是考虑了一种 当前位置一柱擎天的可能性 如果它比其他位置高的很多 也是放不了水的)最左侧和最右侧的格子上面肯定放不了水
用最大值数组 代替遍历行为
我刚开始确实想到用预处理数组了 但是咋想咋不对 你说那左侧右侧最大值 那不得分一个左侧最大值数组 再分一个右侧最大值数组 每个位置的最大值还不同 那不就是遍历了吗 后来看了答案想出来了 先来一个正序的最大值数组 那么当前位置的左侧最大高度就是当前的位置的值
再来一个逆序的数组
3 4 5 2 6 3 1 2 7 2 3 4
7 7 7 7 7 7 7 7 7 4 4 4
右侧最大值就是当前位置
比如说5位置上的最大放水数
那就是6 7比较小的 也就是6
public static int MaxWater(int [] arr) {
int N = arr.length;
int [] leftside = new int [N];
int [] rightside = new int [N];
leftside[0] = arr[0];
rightside[N-1] = arr[N-1];
int sum = 0;
for(int i = 1;i<N;i++) {
leftside[i] = Math.max(arr[i],leftside[i-1]);
}
for(int i = N-2;i>=0;i--) {
rightside[i] = Math.max(arr[i],rightside[i+1]);
}
for(int i = 1;i<N-1;i++) {
int tmp = Math.min(leftside[i], rightside[i])-arr[i];
if(tmp>0) {
sum += tmp;
}
}
return sum;
}这个方法需要两个临时数组的空间 且遍历三遍N大小的数组
吾有一言:一个算法要么对空间不友好 要么对时间不友好 要么对我的脑子不友好 三者至少取其二
所以下面还有一个优化解法
我们这次不需要临时数组 只需要双指针 左指针从1位置开始 右指针从N-2位置开始 再用leftmax记录当前左指针左侧目前最大值 再用rightmax记录当前右指针右侧最大值
对于左指针来说 如果它当前的左边的最大值(leftmax) 小于 右侧目前指针的最大值(rightmax) 右侧目前指针最大值为N 那么接下来的值 如果小于N 那么接下来的位置不会被更新为最大值 如果大于N 那更大于左边了 所以在这种情况 左边的值一定是最大值中的最小值
那如果leftmax > rightmax 是不是就啥都说明不了了呢 确实是这样的 但是我们可以反过来看 rightmax<leftmax了 这又可以执行上面的逻辑
当一个位置的水数判断完后 就把指针向下一个位置推动 判断下一个位置即可
public static int water2(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
int N = arr.length;
int L = 1;
int leftMax = arr[0];
int R = N - 2;
int rightMax = arr[N - 1];
int water = 0;
while (L <= R) {
if (leftMax <= rightMax) {
water += Math.max(0, leftMax - arr[L]);
leftMax = Math.max(leftMax, arr[L++]);
} else {
water += Math.max(0, rightMax - arr[R]);
rightMax = Math.max(rightMax, arr[R--]);
}
}
return water;
}二维装水问题
就是给一个二维数组 其他和上一题一样
你或许会想把它拆成多个一维的 但是不完全是这样 假如拆成一列一列的话 还要受行上面的限制
那么暴力解法就是 把按行拆的结果放进二维数组中 再把按列拆的结果放进二维数组中 然后遍历两个数组 取每个位置上的更小值作为当前位置的结果 然后再累加 费老劲了
优化做法 说实话已经和一维的一点关系没有了
遍历它的外面一圈 把它放到小根堆中 然后弹出堆顶元素 然后把这个元素作为max 然后把它的上下左右四个位置加入到小根堆中 并结算当前位置水数(由于这个位置就是max 所以没有水) 然后以此类推 弹出堆顶 结算水数 然后把上下左右没加入过的位置加到小根堆中 直到弹出的值比当前max 大 那么就把max替换掉 接着刚才的操作 直到堆中没有任何元素
本质上很简单 先把最外面的一圈遍历了 找到第一个缺口(最小值) 如果没有任何缺口也无所谓 随便找一个地方开始行动 然后找到了这个点呢 就用感染算法看它的前后左右 如果比这个点低的话就说明这个地方有水 遍历这个坑 (因为最开始都是把最外面的一圈给加进小根堆 所以下一个弹出的 一定是刚才加入的较小值 如果大的话不会跑到小根堆顶 不要担心从另一边全部漏走的可能性 因为当前我们拿到的点就是最小值) 然后这个坑遍历完了呢 就会换max 换max就是换了个坑的意思
public static int MaxWater(int [][] arr) {
if(arr==null||arr.length==0||arr[0].length==0) {
return 0;
}
int N = arr.length;
int M = arr[0].length;
boolean [][] has = new boolean [N][M];
PriorityQueue<Node> queue = new PriorityQueue<Node>(new mycompare());
for(int i = 0;i<M;i++) {
queue.add(new Node(0, i, arr[0][i]));
has[0][i] = true;
}
for(int i = 0;i<M;i++) {
queue.add(new Node(N-1, i, arr[N-1][i]));
has[0][i] = true;
}
for(int i = 1;i<N-1;i++) {
queue.add(new Node(i, 0, arr[i][M-1]));
has[i][M-1] = true;
}
for(int i = 1;i<N-1;i++) {
queue.add(new Node(i, M-1, arr[i][0]));
has[i][M-1] = true;
}
int max = Integer.MIN_VALUE;
int sum = 0;
while(!queue.isEmpty()) {
Node node = queue.poll();
int row = node.row;
int col = node.col;
int val = node.value;
max = Math.max(max,val);
if(row-1>=0&&has[row-1][col]==false) {
queue.add(new Node(row-1,col,arr[row-1][col]));
has[row-1][col] = true;
if(max-arr[row-1][col]>0) {
sum += max-arr[row-1][col];
}
}
if(col-1>=0&&has[row][col-1]==false) {
queue.add(new Node(row,col-1,arr[row][col-1]));
has[row][col-1] = true;
if(max-arr[row][col-1]>0) {
sum += max-arr[row][col-1];
}
}
if(row+1<N&&has[row+1][col]==false) {
queue.add(new Node(row+1,col,arr[row+1][col]));
has[row+1][col]= true;
if(max-arr[row+1][col]>0) {
sum += max-arr[row+1][col];
}
}
if(col+1<M&&has[row][col+1]==false) {
queue.add(new Node(row+1,col,arr[row][col+1]));
has[row][col+1] = true;
if(max-arr[row][col+1]>0) {
sum += max-arrarr[row][col+1];
}
}
}
return sum;
}刚开始加边界的时候 只加了右侧和上侧 忘记还有两边了
再有 每次应在加入节点时计算水 而不是弹出节点时计算水 我没想明白为啥 虽然没想明白弹出时有啥问题 但还是先这么写吧