2018-3 腾讯编程题

腾讯题目一:
n个连续的整数（1，2，3，4…n），然后要每隔m个数进行一次翻转符号，最开始是负号。保证2m整除n，比如n=8，m=2的话，这个序列就是-1，-2， 3， 4， -5， -6， 7 ，8，然后求前n项和
题解：规律很显然，就是3+（-1） = 2， 4+（-2） = 2， 然后就是m*n/2了，但是n和m都要用long long不然会数据溢出的。

import java.util.Scanner;

public class countResult {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] arr = in.nextLine().split("\\s+");
        long n = Long.parseLong(arr[0]);
        long m = Long.parseLong(arr[1]);

        long result = getResult(n,m);

        System.out.print(result);
    }

    private static long getResult(long n, long m) {
        // TODO Auto-generated method stub
        return  (n/(2*m))*m*m;
    }
}

腾讯第二题:
长度为A的歌曲有X首，长度为B的歌曲有Y首，然后要组成恰好长度K的歌单，不用考虑内部顺序，求一共有多少种组合方式。答案对1e9+7取模

//0-1背包问题
import java.util.Scanner;

public class countSongList {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int len = in.nextInt();
        in.nextLine();
        String[] arr = in.nextLine().trim().split("\\s+");
        int num1 = Integer.parseInt(arr[1]);
        int num2 = Integer.parseInt(arr[3]);

        int[] res = new int[num1+num2];
        for(int i=0;iif(i0]);
            else
                res[i]=Integer.parseInt(arr[2]);
        }

        int[][] dp = new int[num1+num2][len+1];
        for(int i=0;i<=len;i++) {
            dp[0][i]=i-res[0]==0?1:0;
        }
        for(int j =0;j0]=1;
        }

        for(int k=1;kfor(int l=1;l1;l++) {
                if(res[k]<=l)
                    dp[k][l]=(dp[k-1][l]+dp[k-1][l-res[k]])% 1000000007;
                else
                    dp[k][l]=dp[k-1][l]% 1000000007;
            }
        System.out.print(dp[num1+num2-1][len]%1000000007);
    }
}

腾讯第三题：
小Q的父母要出差N天，走之前给小Q留下了M块巧克力。小Q决定每天吃的巧克力数量不少于前一天吃的一半，但是他又不想在父母回来之前的某一天没有巧克力吃，请问他第一天最多能吃多少块巧克力。

import java.util.Scanner;
//本题中是向上取整数，所以 收缩时候要注意~
public class eatChocolate {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String[] arr = in.nextLine().split("\\s+");
        int n = Integer.parseInt(arr[0]);
        int m = Integer.parseInt(arr[1]);

        int number=0;
        int  low = 1;
        int  high = m;
        while(lowint mid = (low+high+1)>>1;
            if(getSum(mid,n)==m) {
                number=mid;
                break;
            }
            if(getSum(mid,n)// low !=mid+1  已经向上取整了  low<=high 因此不可取
                low = mid;
                number = mid;
            }
            if(getSum(mid,n)>m)
                high = mid-1;

        }
        System.out.print(number);
    }

    private static int getSum(int mid,int n) {
        // TODO Auto-generated method stub
        int sum=0;
        for(int i=0;i1)>>1;
        }
        return sum;
    }
}

腾讯第四题：
小Q的公司最近接到m个任务, 第i个任务需要xi的时间去完成, 难度等级为yi。
小Q拥有n台机器, 每台机器最长工作时间zi, 机器等级wi。
对于一个任务,它只能交由一台机器来完成, 如果安排给它的机器的最长工作时间小于任务需要的时间, 则不能完成,如果完成这个任务将获得200 * xi + 3 * yi收益。
对于一台机器,它一天只能完成一个任务, 如果它的机器等级小于安排给它的任务难度等级, 则不能完成。
小Q想在今天尽可能的去完成任务, 即完成的任务数量最大。如果有多种安排方案,小Q还想找到收益最大的那个方案。小Q需要你来帮助他计算一下。

//本题一个重要的思路就是在同样可以处理任务的机器上，优先使用等级低的机器
//和应该为 long 类型
//comparator 对数据类型的排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;


class Node{
    int t;
    int w;
}

public class bestAllocate {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        Node mach[] = new Node[n];
        Node task[] = new Node[m];
        for(int i=0;inew Node();
            mach[i].t = in.nextInt();
            mach[i].w = in.nextInt();
        }
        for(int i=0;inew Node();
            task[i].t = in.nextInt();
            task[i].w = in.nextInt();
        }
        Arrays.sort(mach,new Comparator() {

            @Override
            public int compare(Node arg0, Node arg1) {
                // TODO Auto-generated method stub
                if(arg1.t==arg0.t)
                    return arg1.w-arg0.w;
                else
                    return arg1.t-arg0.t;
            }

        });

        Arrays.sort(task,new Comparator() {

            @Override
            public int compare(Node arg0, Node arg1) {
                // TODO Auto-generated method stub
                if(arg1.t==arg0.t)
                    return arg1.w-arg0.w;
                else
                    return arg1.t-arg0.t;
            }           
        });
        int diffcult[] = new int[105];
        int j=0,num1=0,sum1=0;
        for(int i=0;iwhile(j=task[i].t) {
                diffcult[mach[j].w]++;
                j++;
            }
            for(int k=task[i].w;k<=100;k++) {
                if(diffcult[k]>0) {
                    num1++;
                    System.out.print(i+" ");
                    sum1+=200*task[i].t+3*task[i].w;
                    diffcult[k]--;
                    break;
            }
            }
        }
       System.out.println(num+" "+sum);

    }
}

腾讯题目五：
牛牛和羊羊正在玩一个纸牌游戏。这个游戏一共有n张纸牌, 第i张纸牌上写着数字ai。
牛牛和羊羊轮流抽牌, 牛牛先抽, 每次抽牌他们可以从纸牌堆中任意选择一张抽出, 直到纸牌被抽完。
他们的得分等于他们抽到的纸牌数字总和。
现在假设牛牛和羊羊都采用最优策略, 请你计算出游戏结束后牛牛得分减去羊羊得分等于多少

//注意comparator的用法
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class compareNumber {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        ArrayList arr = new ArrayList<>();
        int xiaoniu=0;
        int xiaohua=0;
        for (int i=0;inew Comparator() {

            @Override
            public int compare(Object arg0, Object arg1) {
                // TODO Auto-generated method stub
                Integer s1 = (Integer) arg1;
                Integer s0 = (Integer) arg0;
                if(s0return 1;
                return -1;
            }});
        for(int i =0;iif(i%2==0)
                xiaoniu +=arr.get(i);
            else 
                xiaohua += arr.get(i);
        }
        System.out.print(xiaoniu-xiaohua);
    }
}