２０１５年真题

１、数字按位加和

class Kruskal{
    public static void main(String[] args) {
        int a = 1232456;
        String s = String.valueOf(a);
        int sum = 0;
        for(int i =0;i<s.length();i++){
            sum+=(s.charAt(i)-'0');
        }
        System.out.println(sum);
    }
}

２、

循环节长度

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153.....  其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。

请仔细阅读代码，并填写划线部分缺少的代码。

    public static int f(int n, int m)
    {
        n = n % m;
        Vector v = new Vector();

        for(;;)
        {
            v.add(n);
            n *= 10;
            n = n % m;
            if(n==0) return 0;
            if(v.indexOf(n)>=0)  _________________________________ ;  //填空
        }
    }

注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

tip:Vector 可实现自动增长的对象数组。 
java.util.vector提供了向量类(Vector)以实现类似动态数组的功能。 
创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。但是现在基本上已经不用ｖｅｃｔｏｒ了，一般用的数ｌｉｓｔ，然后，，，这个题一直导致我误解的地方是vector.index(ｎ)是在ｖｅｃｔｏｒ中查找有无ｎ那个元素，而不是去看ｎ位是啥

import java.util.Vector;

class Kruskal{
    public static void main(String[] args) {
       int x = f(11,13);
        System.out.println(x);
    }
    public static int f(int n, int m)
    {
        n = n % m;
        Vector v = new Vector();

        for(;;)
        {
            v.add(n);
            n *= 10;
            n = n % m;
            if(n==0) return 0;
            if(v.indexOf(n)>=0)  return v.size()-v.indexOf(n);    //填空
        }
    }

}

这个题，，真是，，，，我搞不懂为什么不存除数而去存了余数，但是可能么算下是一样的把，，然后，，必须要会用ｄｅｂｕｇ了，，不然这个一个一个去手算例举真是痛苦死人呀

３、

加法变乘法

我们都知道：1+2+3+ ... + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：
1+2+3+...+10*11+12+...+27*28+29+...+49 = 2015
就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

注意：需要你提交的是一个整数，不要填写任何多余的内容。*/

o,,,ｓｈｉｔ，这题，，，我真的是神了个奇，我刚开始在写什么啊，还一直报空指针异常

public class Kruskal
{
    static int[] arr;
    public static void main(String[] args) {
        int arr[] =new int[51];
        for(int i =1;i<=49;i++){
            arr[i] = i;
        }
        for(int i =1;i<=48;i++){
            for(int j = i+1;j<=48;j++){       //i和ｉ＋１ 　　　　ｊ和ｊ+1
                if(arr[i]*arr[i+1]+arr[j]*arr[j+1]+sum(1,i)+sum(i+2,j)+sum(j+2,50)==2015){
                    System.out.println(arr[i]);
                }
            }
        }
    }
    static int sum(int i,int j){
        int ans = 0;
        for(int x = i;x<=j-1;x++){
            ans+=arr[x];
        }
        return ans;
    }
}

这是正确的代码

public class Test48 {
    public static void main(String[] args) {
        for (int i = 1; i <= 46; i++) {
            for (int j = i + 2; j <= 48; j++) {
                if (i * (i + 1) - (i + i + 1) + j * (j + 1) - (j + j + 1) == 2015 - 1225)
                    System.out.println(i + " " + j);
            }
        }
    }
}

４、

牌型种数

小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

请填写该整数，不要填写任何多余的内容或说明文字。

一张１，两张一，三张一，四张一
难不成１３次循环，里面一次次判断？？？

这就是纯暴力了

#include <iostream>
using namespace std;
int main()
{
    int sum=0;
    for(int a=0; a<=4; a++)
        for(int b=0; b<=4; b++)
            for(int c=0; c<=4; c++)
                for(int d=0; d<=4; d++)
                    for(int e=0; e<=4; e++)
                        for(int f=0; f<=4; f++)
                            for(int g=0; g<=4; g++)
                                for(int h=0; h<=4; h++)
                                    for(int i=0; i<=4; i++)
                                        for(int j=0; j<=4; j++)
                                            for(int k=0; k<=4; k++)
                                                for(int l=0; l<=4; l++)
                                                    for(int m=0; m<=4; m++)
                                                    {
                                                        if(a+b+c+d+e+f+g+h+i+j+k+l+m==13)
                                                            sum++;
                                                    }
                                                    cout<<sum<<endl;
    return 0;
}

ｔｉｐ：这种排列组合问题，一般都是用的递归，

比如说我第一次抓１张，下一次规模就转移了，转移成了剩下的１２张中间抓出一张来，那出口呢？，直到规模为０是为出口，

dfs的深度是牌的类型，每种牌可以选0~4种，选的牌的总数相加==13.....

有一点点平时没有见过是因为那个递归调用套在一个循环里，平时应该遇见过。

传说中的递归中循环

public class _07_牌型种数 {
  private static int ans;

  public static void main(String[] args) {
    f(0, 0);
    System.out.println(ans);
  }

  private static void f(int k, int cnt) {
    if (k > 13 || cnt > 13) return;
    if (k == 13 && cnt == 13) {
      ans++;
      return;
    }
    for (int i = 0; i < 5; i++) {　　//ｋ就是游标了
      f(k + 1, cnt + i);
    }
  }
}

答案：3598180 

５、

垒骰子

赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦～

「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。

「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。

「样例输入」
2 1
1 2

「样例输出」
544

 

一般问多少种，可以用试探的方法也就是暴力递归的方式，但是要是递归太深的话就改成动态规划或者记忆性递归（就是有交叉子问题就改成记忆性递归），

那么，咋做呢，这个题题意难懂哎，没有清楚四周转是不是以后给新的情况，不过看例子那么大，应该是不同的情况了，所以最开始定哪个呢，定最上面的哪个吧，定最上面筛子的顶是数字几，然后把情况分给他的下面筛子也就是第二个筛子，有６中情况朝上但是不能包括冲突的问题，，依次解决。

那么如何记录筛子的对立面呢？？？用数组啊

第一种就是看暴力递归了，，思路是对的，但是黑人问号脸，，１２　２１的样例结果一直是９２？？？

import java.util.Scanner;

class test6{
    static int n;
    static int m;
    static int op[] = new int[7];
    static int MOD = 1000000007;
    static int conflict[][] = new int[7][7];
    static void  init(){
        op[1] = 4;
        op[4] = 1;
        op[2] = 5;
        op[5] = 2;
        op[3] = 6;
        op[6] = 3;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        init(); //预处理一下
        for(int i = 0;i<6;i++){
            for(int j=0;j<6;j++){
                conflict[i][j] = 1;//１就代表不冲突
            }
        }
        for(int i =0;i<m;i++){
            int a = sc.nextInt();
            int b =sc.nextInt();
            conflict[a][b] = 0;
            conflict[b][a] = 0;
        }
        long ans = 0;
        for(int up=1;up<=6;up++){
            ans = (ans+4*f(up,n-1))%MOD; //递归的写法就这一步，分下去ｏｋ，在处理一下ｆ函数就可以啦
        }
        System.out.println(ans);
    }


    static long f(int up,int cnt){
        if(cnt ==0){
            return 1;//这是出口
        }
        long ans = 0;
        for(int upp = 1;upp<=6;upp++){
            if(conflict[op[up]][upp] ==0){
                continue;
            }else {
                ans+= f(upp,cnt-1);
            }
        }
        return ans;
    }

}

但是呢，，这个递归递归的 有点多呀，每一个都是６种，，那么，来用动归吧

第二种：ｄｐ写法

说白了就是递推，从下面往上面放，而不是递归那种从上面往下面放

此处应有表格呀，ｄｐ【ｉ】【ｊ】表示在第ｉ层，ｊ朝上的方案数，他等于ｄｐ【ｉ－１】【ｘ】　ｘ从１到６的所有的和，

ｊ是这一层ｊ朝上，ｘ是上一层什么朝上，所以　且ｏｐ【ｊ】与ｘ要不冲突

这个不太好懂的话自己举个例子感受一下，，推导到最上面等于啥呢，等于ｄｐ【ｎ】【ｊ】　ｊ从１到６的和，

只需要记录情况的可能数而不需要记录筛子的样子是因为他是ｄｐ，是一个步步为营的状态，

然后这个ｄｐ可以优化为滚动数组，因为他只需要ｉ－１就可以了

这里呢，又要有一个新的快速幂写法了，（整数快速幂）https://www.cnblogs.com/cmmdc/p/6936196.html

import java.util.Scanner;

class test6{
    static int n;
    static int m;
    static int op[] = new int[7];
    static int MOD = 1000000007;
    static int conflict[][] = new int[7][7];
    static long dp[][] =new long[2][7];

    static void  init(){
        op[1] = 4;
        op[4] = 1;
        op[2] = 5;
        op[5] = 2;
        op[3] = 6;
        op[6] = 3;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        init(); //预处理一下
        for(int i = 0;i<6;i++){
            for(int j=0;j<6;j++){
                conflict[i][j] = 1;//１就代表不冲突
            }
        }
        for(int i =0;i<m;i++){
            int a = sc.nextInt();
            int b =sc.nextInt();
            conflict[a][b] = 0;
            conflict[b][a] = 0;
        }
        for(int j = 1;j<=6;j++){ //初始化ｄｐ的第一行
            dp[0][j] = 1;
        }
        int cur = 0;//这就是一个滚动数组的一个道具，
        for(int level = 2;level<=n;level++){
            cur = 1-cur;
            for(int j =1;j<=6;j++){
                dp[cur][j] = 0;
                //将于ｏｐ【ｊ】不冲突的上一层格子数累加起来
                for(int i = 1;i<=6;i++){
                    if(conflict[op[j]][i]==0) continue;
                    dp[cur][j] = (dp[cur][j]+ dp[1-cur][i])&MOD;
                }
            }
        }
        long sum = 0;
        for(int k =1;k<=6;k++){
            sum = (sum+dp[cur][k])&MOD;
        }
        //然后每一个都有４中，所以要ｓｕｍ×４的ｎ次方
        //快速幂，先求４的ｎ次方
        long tmp = 4;
        long ans = 1;

        while (n!=0){
            if (n&1==1 ) ans = (ans*tmp)%MOD;　//********************************这儿一直说不对，，好蜜汁呀
            tmp = (tmp*tmp)%MOD;
            n>>1;
        }

        System.out.println((sum*ans)%MOD);
    }

}

最后一种解法，，矩阵快速幂https://blog.csdn.net/qq_34594236/article/details/53616283

 左边那个打的矩阵里比如第一行就是１面朝上的情况，他和２面冲突，那就在１面朝上哪一行的二面那个写成０，那样他们就不能累加了

那么结果就是左边那个矩阵的ｎ－１次方成上右边那一排１，，，然后得到一个列矩阵，所有元素相加就ＯＫ

上面这个是我的代码，，，真的不知道哪里有问题，，那个整数快速幂一直报错，

import java.util.Scanner;

class test6{
    static int n;
    static int m;
    static int op[] = new int[7];
    static int MOD = 1000000007;
    static long conflict[][] = new long[6][6];
    static long dp[][] =new long[2][7];

    static void  init(){
        op[1] = 4;
        op[4] = 1;
        op[2] = 5;
        op[5] = 2;
        op[3] = 6;
        op[6] = 3;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        init(); //预处理一下
        for(int i = 0;i<6;i++){
            for(int j=0;j<6;j++){
                conflict[i][j] = 1;//１就代表不冲突
            }
        }
        for(int i =0;i<m;i++){
            int a = sc.nextInt();
            int b =sc.nextInt();
            conflict[a-1][b-1] = 0;
            conflict[b-1][a-1] = 0;
        }
        //求冲突矩阵的ｎ-1次方
        long [][]pow_n  = mpow(conflict,n-1);
        long ans = 0;
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                ans = (ans + pow_n[i][j]) % MOD;
            }
        }
        System.out.println(ans*my_pow(4,n));

    }
    static long[][] mpow (long[][]conflict,int n){
        long[][] e = new long[6][6];
        for(int i=0;i<6;i++){
            for(int j =0;j<6;j++){
                if(i==j) e[i][j] =1;
                else e[i][j] = 0;
            }
        }
        while (n!=0){
            if((n&1)==1){
                e = mMule(e,conflict);
            }
            conflict = mMule(conflict,conflict);
            n>>=1;
        }
     return e;
    }

    static long[][] mMule(long[][] a,long[][]b ){
        long[][] ans =new long[6][6];
        for(int i=0;i<6;i++){
            for(int j= 0;j<6;j++){
                for(int k = 0;k<6;k++){
                    ans[i][j] = (ans[i][j] +ans[i][k]*b[k][j])%MOD;
                }
            }
        }
        return ans;
    }

    static long my_pow(int tmp,int n){
        int ans =0;
        while (n!=0){
            if(n&1 ==1) ans =(ans*tmp);
            tmp = tmp*tmp;
            n>>1;
        }
        return ans;
    }


}

这个是我ｃｏｐｙ的正确的代码 

public class _09_垒骰子 {
  static int op[] = new int[7];
  private static int n;
  private static int m;
  private static final long MOD = 1000000007;

  static void init() {
    op[1] = 4;
    op[4] = 1;
    op[2] = 5;
    op[5] = 2;
    op[3] = 6;
    op[6] = 3;
  }

  public static void main(String[] args) {
    init();
    Scanner sc = new Scanner(System.in);
    n = sc.nextInt();
    m = sc.nextInt();
    long conflict[][] = new long[6][6];
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 6; j++) {
        conflict[i][j]=1;
      }
    }
    //建立冲突矩阵
    for (int i = 0; i < m; i++) {
      int a = sc.nextInt();
      int b = sc.nextInt();
      conflict[op[a] - 1][b - 1] = 0;
      conflict[op[b] - 1][a - 1] = 0;
    }
    //  求冲突矩阵的n-1次方
    long[][] mPow_n_1 = mPow(conflict, n - 1);
    //累加矩阵的每个元素
    long ans = 0;
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 6; j++) {
        ans = (ans + mPow_n_1[i][j]) % MOD;
      }
    }
    //ans*4^n
    System.out.println(ans * power(4, n) % MOD);
  }

  private static long power(long i, int n) {
    long ans = 1;
    while (n != 0) {
      if ((n & 1) == 1) ans = (ans * i) % MOD;
      i = i * i % MOD;
      n >>= 1;
    }
    return ans;
  }

  /*矩阵的快速幂*/
  private static long[][] mPow(long[][] conflict, int n) {
    long[][] e = new long[6][6];
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 6; j++) {
        if (i == j) e[i][j] = 1;
        else e[i][j] = 0;
      }
    }
    while (n != 0) {
      if ((n & 1) == 1) {
        e = mMul(e, conflict);
      }
      conflict = mMul(conflict, conflict);
      n >>= 1;
    }

    return e;
  }

  private static long[][] mMul(long[][] a, long[][] b) {
    long[][] ans = new long[6][6];
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 6; j++) {
        for (int k = 0; k < 6; k++) {
          ans[i][j] = (ans[i][j] + a[i][k] * b[k][j]) % MOD;
        }
      }
    }
    return ans;
  }
}

６、

生命之树

在X森林里，上帝创建了生命之树。

他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。
上帝要在这棵树内选出一个非空节点集S，使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, ..., vk, b} 使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。

在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。
这个最大的和就是上帝给生命之树的评分。

经过atm的努力，他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm 不擅长计算，他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。

「输入格式」
第一行一个整数 n 表示这棵树有 n 个节点。
第二行 n 个整数，依次表示每个节点的评分。
接下来 n-1 行，每行 2 个整数 u, v，表示存在一条 u 到 v 的边。由于这是一棵树，所以是不存在环的。

「输出格式」
输出一行一个数，表示上帝给这棵树的分数。

「样例输入」
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5

「样例输出」
8

「数据范围」
对于 30% 的数据，n <= 10
对于 100% 的数据，0 < n <= 10^5, 每个节点的评分的绝对值不超过 10^6 。

这个问题，，首先是个什么问题？？？

ｔｉｐ；题目很明显的说这是一棵树了，，而且有ｎ个顶点，就是接下来有ｎ－１行，因为一棵树有ｎ个顶点，就会有ｎ－１条边的。注意啊，这里知道是树思路就清晰很多了

树形ｄｐ我也真是６６６了

第一种呢，暴力：枚举所有的子集，然后每个子集用ｄｆｓ都去看是否能够达到所有点都能联通

第二种，比较神奇了，无根树转有根树的递归

首先，无根树转化为有根树，在每一个有根树中，这颗树的子树如何加和大于０，那就会对他产生正向的影响，如果小于０，那就不要那棵树了，但是这里系统的想一下分成的情况：１，要哪个根，前提是那个根是大于０的，那这个根下的所有子树就开始递归就好了　　２，不要那个根，没有那个根就感觉变成了森林一样，，在所有森林中找个最大就出来了，同样每课小树都用递归就好了。。神奇的地方在这里：：：无根树变有根树，每次选不同的点起始结果是一样的。最终结果是一样的。

但是这里的递归，因为一直递归到了叶子节点，然后从叶子开始计数，所有就相当于一个记忆性的东西了，要不要再转成一个树状ｄｐ都可以

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class test6{
    static int w[];
    static List<Integer> []g;
    static int n;
    static int ans = 0;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n =  sc.nextInt();
        g = new ArrayList[n+1];
        initG();//list数组里每一个都要初始化一下称为一个小的ｌｉｓｔ，不然不能用
        w = new int[n+1];
        for(int i =1;i<=n;i++){
            w[i] = sc.nextInt();
        }
        for(int i=0;i<n-1;i++){
            int a = sc.nextInt();
            int b = sc.nextInt();//下来就用邻接表来存吧，起始就是ｌｉｓｔ，跟他连，被连的就是ｃｈｉｌｄｒｅｎａ
            g[a].add(b);
            g[b].add(a);
        }
        dfs(1,0);
        System.out.println(ans);
    }
    static void dfs(int u,int fa){
        for(int i = 0;i<g[u].size();i++){
            Integer child = g[u].get(i);
          if(child==fa) continue;//这是啥,就这一行，没有他就全报stackoverflow!!!因为会死循环的！！
            dfs(child,u);
            if(w[child]>0){
                w[u]+=w[child];//这儿比较巧妙，因为直接就存在了ｗ[i]那个数组，因为这里ｄｆｓ会一下子扎到最根处，也就是一直到最后的叶子节点，这里如果ｕ加叶子节点大于０，那就要他，直接写到他那里就可以了
            }
            if(w[u]>ans){
                ans = w[u];
            }
        }
    }
    static void initG(){
        for(int i=0;i<n+1;i++){
            g[i] = new ArrayList<Integer>();
        }
    }
}

代码有一个小小的问题，就是应该把ｉｎｔ改成ｌｏｎｇ，但是我不知道为啥，明明数据范围也只到１０^5，而引用一个大佬说的话：long型数据存储的数范围广而大 我给你举个例子
比方说 int只能存215612316这么大的数 long就可以存 121132131546523123156123这么大的数

？？？？？为什么呀

第三种：这种是我能懂的办法无疑了，直接把当成图来做了

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class test6{
    static int w[];
    static List<Integer> []g;
    static int n;
    static int ans = 0;
    static int [][]arr;
    static boolean vis[];
    static int  max = 0;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n =  sc.nextInt();
        arr = new int[n+1][n+1];
        w = new int[n+1];
        vis = new boolean[n+1];
        for(int i =1;i<=n;i++){
            w[i] = sc.nextInt();
        }
        for(int i=0;i<n-1;i++){
            int a = sc.nextInt();
            int b = sc.nextInt();//下来就用邻接表来存吧，起始就是ｌｉｓｔ，跟他连，被连的就是ｃｈｉｌｄｒｅｎａ
           arr[a][b] = 1;
           arr[b][a] =1;

        }
        dfs(1);
        System.out.println(max);
    }
    static void dfs(int m ){
        vis[m] = true;
        for(int i=1;i<=n;i++){
            if(vis[i] ==false && arr[m][i] !=0){
                dfs(i);
                if(w[m]<(w[m]+w[i])){
                    w[m] = w[m]+w[i];
                }
                max = Math.max(max,w[m]);
            }
        }

    }
    static void initG(){
        for(int i=0;i<n+1;i++){
            g[i] = new ArrayList<Integer>();
        }
    }
}

第四种：树形ｄｐ

首先，树形ｄｐ是啥意思嘞？？

先来一道例题：

二叉苹果树，

然后再写树形ｄｐ的代码，，，这里　我还没有看懂，，，，，