准备笔试第21天，牛客.十字爆破牛客.比木名居的桃子牛客.chinka蜜柑01背包

 

目录

 

牛客.十字爆破

牛客.比木名居的桃子

牛客.chinka蜜柑

01背包

---

牛客.十字爆破

就是上下左右加上，但是会遇到的问题就是，这块并不容易去获取得分，如果可能要四重循环，遍历这一行，这一列，然后把他们存在一个数组里面，要存很多次

牛客.比木名居的桃子

初始肯定是暴力解法，每个遍历之后，然后把从i开始后k个，来遍历

但是我们暴力不好解决，暴力会超时

所以方法二：滑动窗口找定，然后找定长的数字串，计算定长为k的数字串之和，剩下的就是简单模拟，我们需要关注的是滑动窗口的形态，如何写滑动窗口，模拟判定倒是很容易

import java.util.*;
public class Main{
public static void main(String[] args)  {
   Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int k = in.nextInt();
        long []a=new long[n];
        long []b=new long[n];
        for(int i=0;i<n;i++){
            a[i]=in.nextLong();
        }
        for(int i=0;i<n;i++){
            b[i]=in.nextLong();
        }
        int left=0;int right=0;
        long hSum=0;long sSum=0;
        long hMax=0;long sMin=0; long begin=0;
         while (right<n){
            //进入窗口
            hSum+=a[right];
            sSum+=b[right];
            //出窗口
            while(right-left+1>k){
                hSum-=a[left];
                sSum-=b[left];
                left++;
            }
            if(right-left+1==k){
                if(hSum>hMax){
                    begin=left;
                    hMax=hSum;
                    sMin=sSum;
                }else if(hSum==hMax&&sMin>sSum){
                    begin=left;
                    sMin=sSum;
                }
            }
            right++;
        }
        System.out.println(begin+1);


    }
}

牛客.chinka蜜柑

看似和桃子相同，实则不一样，

排序/堆，TOPK问题，其实他就是想问这个酸度和甜度前k个，既能保证甜度的同时，还能保证酸度。从大到小的排列。

定义比较方法时:

1.优先比较甜度:谁大谁靠前

2.当甜度相同时候，比较酸度，谁酸小谁靠前。

这里就是利用的Comparator接口，重写了compare方法，定义了一个比较大小的规则。这个方法会有两个参数 a b，有一个int类型的返回值，如果返回值大于0 ，就表示 a>b,反之 就是 a<b ,如果等于0 就表示这两个相等 

(假如是从大到小的情况就是)b-a，首先就是Array.sort()默认是从小到大排序的，正常情况下，a和b的比较，应该是用a-b，比如a是大于b的，那么原本a-b>0的结果，就表示a 是大于b的，按照sort()排序，a就在b的前面。方法里返过来改成 b-a就变成<0了，然后就会觉得a是小于b的，那么本来应该a排在b后面，就变成了a排在了b前面，就变成了从大到小排列

 public static void main(String[] args) throws IOException {
            //TOPK
                Scanner in = new Scanner(System.in);
                // 注意 hasNext 和 hasNextLine 的区别
                int n = in.nextInt();
                int k = in.nextInt();
                Orange []orange=new Orange[n];
                for(int i=0;i<n;i++){
                    orange[i]=new Orange();
                    orange[i].a=in.nextInt();
                }
                for(int i=0;i<n;i++){
                    orange[i].b=in.nextInt();
                }
                //每次拿两个对象做比较,x,y分别表示两个orange
                Arrays.sort(orange,(x,y)->{
                    //如果两个橘子甜度相同的情况下，就返回酸度
                    //当两个橘子甜度相同时候，谁的酸度小谁在前面
                    if(x.b==y.b) return x.a-y.a;
                    //谁大谁在前， 不同的时候，
                    return y.b-x.b;
                });
                //提取结构
                long x=0;
                long y=0;
                for(int i=0;i<k;i++){
                    x+=orange[i].a;
                    y+=orange[i].b;
                }
                System.out.println(x+ " " +y);

            }
        }
//需要读入橘子的酸度和甜度
class Orange{
    int a;//酸度
    int b;//甜度
    Orange(){}
    Orange(int a,int b){
        this.a=a;
        this.b=b;
    }
}

01背包

01背包，

动态规划:背包问题

状态表示固定的

dp[i][j]:从前i个物品中挑选，总体积不超过j，此时的最大重量

2.状态转移方程

选i,不选i

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算01背包问题的结果
     * @param V int整型 背包的体积
     * @param n int整型 物品的个数
     * @param vw int整型二维数组 第一维度为n,第二维度为2的二维数组,vw[i][0],vw[i][1]分别描述i+1个物品的vi,wi
     * @return int整型
     */
    public int knapsack (int V, int n, int[][] vw) {
        // write code here
        //从前i个物品中挑选总体积不超过j，此时的最大重量
        int[][]dp = new int[n + 1][V + 1];
        //dp[0][j]:从前0个，就核心是；
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                dp[i][j] = dp[i - 1][j ];
                if (j - vw[i - 1][0] >= 0)
                    dp[i][j] = Math.max(dp[i - 1][j],
                                        dp[i - 1][j - vw[i - 1][0]] + vw[i - 1][1]);
            }
        }
        int max = 0;
        //最后挑选，从前n个位置挑选，体积不大于V的
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                max = Math.max(dp[i][j], max);
            }
        }

        return max;
    }
}

假如他问背包恰好装满的情况:

还是从i个物品中，背包恰好装满

从前i个物品中挑选，恰好总体积等于j,所有选法中，能挑选的最大价值

这里要设定dp[i][j]==-1(总体积是凑不到j的，所以设置成-1,假如是0，就和dp[0][0]混到一起了)

状态转移方程时:dp[i-1][j-v[i]]需要!=-1。 不然他这个+会出现一些问题。