网易秋招校招编程题

　　网易内推面试凉了，再战正式批笔试，选择和简答略难，编程题很良心，基本就是模拟、找规律，略加思考就能解出来的题目，本弱鸡只有在良心网易笔试才能AK。

1、翻转翻转

　　

　　这题一开始没思路，ac了后两题后再回来思考，发现只需要判断某个位置周围有几个点，就代表了那个位置会被别的点翻转几次，那么如何求周围有几个点呢？

　　简单的把位置分成3类：

　　　　一类是四个顶点：每个顶点会被翻转4次（加上自己翻转一次）。

　　　　第二类是四条边（不含顶点）：边上的点会被翻转6次。

　　　　第三类就是中间部分：中间的每个点会被翻转9次。

　　因此翻转9次的点就是我们需要的啦，求出中间部分的数量即可，再考虑只有一条边的时候，只有一个点的时候是特殊的，别的都是边长度 -2 。

　　（坑！数据量n,m是10^10，所以相乘的结果肯定比int大，要用long！然后2*（n+m-2）没用long转型也没过，小小的怀疑一下数据是不是比给的10^10范围还要大一点点）。

　　代码如下：

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {// 注意while处理多个case
            int t = in.nextInt();
            while (t != 0) {
                int n = in.nextInt();
                int m = in.nextInt();
                helper(n,m);
                t--;
            }
        }
    }
    
    
    static void helper(int n,int m){
        if(m < n){
            int t = n;
            n = m;
            m = t;
        }
        if(n == 1 && m == 1){
            System.out.println(1);
        }else if (n == 1) {
            System.out.println(m-2);
        }else {
            long res = 1;
            System.out.println(res*n*m-2*(n+m-2));
        }
    }

2、买房

　　

　　找规律：

　　最小可能就是所有人都挤在一起，不管怎么样都没有位置可以住，所以直接输出0，

　　最大可能分成两种情况：

　　　　已经住进去的人比房子数一半（实际是一半+1）小，那么就可以“#.#.#”这样排序，那么最大的可能数就是已经住进去的人数减1。

　　　　另一种情况，多出来的人会把可能的位置占掉，那么最多情况就是剩下的空位，因为每个位置都是可以住的。

　　上代码：

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {//注意while处理多个case
            int t = in.nextInt();
            while(t!=0){
                int n = in.nextInt();
                int k = in.nextInt();
                int max = 0;
                if(k >= 2 && n > k){
                    if(k <= (n+1)/2){
                        max = k-1;
                    }else {
                        max = n-k;
                    }
                }
                
                System.out.println(0 + " " + max);
                t--;
            }
        }
    }

3、倒香槟

　　

　　想了几分钟没有特别好的解法，只能硬着头皮模拟，n,m的数据量有两个令我很疑惑，当时的想法就是做个模拟跑个20%的测试用例也够了，然后模拟完了之后发现过了！！　　

　　上代码：

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {//注意while处理多个case
            int n = in.nextInt();//n层
            int m = in.nextInt();//m条指令
            int[] array = new int[n+1];
            int[] now = new int[n+1];
            for(int i = 0;i<n;i++){
                array[i+1] = in.nextInt();
            }
            for(int j = 0;j<m;j++){
                int inc = in.nextInt();
                if(inc == 2){
                    int deepth = in.nextInt();
                    int num = in.nextInt();
                    add(deepth, num, array, now);
                }else if (inc == 1) {
                    int deepth = in.nextInt();
                    System.out.println(now[deepth]);
                }
            }
        }
    }
    
    static void add(int n,int num,int[] array,int[] now){
        int maxadd = 0;
        for(int i = n;i<array.length;i++){//每一层流下来
            maxadd = array[i] - now[i];
            if(maxadd >= num){//比当前层最多能容纳的少就直接倒进去，返回
                now[i] += num;
                return;
            }
            now[i] = array[i];
            num -= maxadd;
         }
    }