题目A：https://ac.nowcoder.com/acm/contest/9246/A

• 题解：首先对数组DEF进行升序排序，对于第i个怪物来说，它的防御值为DEF[i]，如果杀死第i - 1个怪物所需的天数为res，那么杀死第i个怪物的天数为res = Math.max(res + 1, DEF[i]）
• java代码实现：

  import java.util.*;
  public class Solution {
  /**
   * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
   * 
   * @param n int整型 
   * @param DEF int整型一维数组 
   * @return int整型
   */
  public int Minimumdays (int n, int[] DEF) {
      Arrays.sort(DEF);
      int res = Integer.MIN_VALUE;
      for(int i = 0; i < n; i++){
          res = Math.max(res + 1, DEF[i]);
      }
      return res;
  }
  }

题目B：https://ac.nowcoder.com/acm/contest/9246/B

• 题解：由于a[1]=2，a[2]=6，且对于所有的n>=3,a[n] = 2a[n-1] + 3a[n-2]，则观察得出a[2] = 3a[1]，那么a[3] = 2a[2] + 3a[1] = 2a[2] + a[2] = 3[2]，以此类推a[n] = 3a[n-1]，是一个首项为2，公比为3的等比数列，因此a[n] = 2X3^(n - 1)。同理对于b[1]=7,b[2]=35,且所有的n>=3,b[n] = 3b[n-1] + 10b[n-2]来说，b[n] = 7X5^(n - 1)。那么c[n] = a[n]Xb[n]=14X15^(n-1)。

• 因此可以使用快速幂法求出15^(n-1)，在这里每一步都对mod=1e+9进行取余运算，关于快速幂法的解释可参见算法学习笔记(4):快速幂，这道题也可以使用矩阵快速幂的方法，具体做法可以自己去查下资料

• java代码实现：

  import java.util.*;
  public class Solution {
  /**
  * 返回c[n]%1000000007的值
  * @param n long长整型 即题目中的n
  * @return int整型
  */
  //快速幂法
  int mod = (int)1e9+7;
  public long power(long a, long b){
      long res = 1;
      while(b != 0){
          if((b & 1) == 1)
          res = (res * a) % mod;
          a = (a * a) % mod;
          b = b >> 1;
      }
      return res;
  }
  
  public int Answerforcn (long n) {
      return (int)(14 * power((long)15, n - 1) % mod);
  }
  }

题目C：https://ac.nowcoder.com/acm/contest/9246/C

• 题解：假设数组a[]为完全k叉树的层序遍历(bfs序)，那么a[i]的第j个孩子节点为a[i * k + j]，而题目只给出了先序遍历(dfs序)，由于dfs序不能通过数组下标来判断孩子节点是否存在，同时bfs可以通过bfsOrder * k + i < n是否成立来进行判断，因此可以在进行先序遍历的同时来维护一个层序遍历来进行判断，具体可参见代码

• java代码实现：

  import java.util.*;
  public class Solution {
  /**
   *
   * @param k int整型 表示完全k叉树的叉数k
   * @param a int整型一维数组 表示这棵完全k叉树的Dfs遍历序列的结点编号
   * @return long长整型
   */
  int dfsOrder = 0;
  long res = 0;
  //注意这里bfsOrder要使用long，因为bfsOrder * k + i可能会超过int    
  public void dfs(int k, int[] a, long bfsOrder, int n){
      if(dfsOrder >= n)
          return;
      int parent = a[dfsOrder];//获得父亲节点的值
      for(int i = 1; i <= k; i++){//依次判断k个孩子节点是否存在
          if(bfsOrder * k + i < n){//通过bfs序来判断第i个孩子节点是否存在
              dfsOrder++;
              res += (parent ^ a[dfsOrder]);
              dfs(k, a, bfsOrder * k + i, n);//递归地对第i个孩子节点进行dfs(先序遍历)
          }else
              break;
      }
  }
  
  public long tree6 (int k, int[] a) {
       dfs(k, a, 0, a.length);
       return res;
  }
  } 

• 这里顺便写下根据完全k叉树的先序遍历创建完全k叉树，然后在进行层序遍历的过程中计算结果，下面贴下代码（只能过80%，可能是在节点过多的情况下超出限制内存）：

import java.util.*;
public class Solution {
    //k叉树节点
    public class Node{
        public int val;
        public Node[] child;
        public Node(int data, int k){
            this.val = data;
            child = new Node[k];
        }
    }

    int dfsOrder = 0;
    //根据先序遍历创建完全k叉树
    public Node createTree(int k, int[] a,int bfsOrder){
        if(dfsOrder >= a.length)
            return null;
        Node head = new Node(a[dfsOrder], k);
        for(int i = 1; i <= k; i++){
            if(bfsOrder * k + i < a.length){
                dfsOrder++;
                head.child[i - 1] = createTree(k, a, bfsOrder * k + i);
            }else{
                break;
            }
        }
        return head;
    }

    /**
     *
     * @param k int整型 表示完全k叉树的叉数k
     * @param a int整型一维数组 表示这棵完全k叉树的Dfs遍历序列的结点编号
     * @return long长整型
     */
    public long tree6 (int k, int[] a) {
        Node head = createTree(k, a, 0);//创建完全k叉树
        long res = 0;
        Queue queue = new LinkedList();
        queue.add(head);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Node cur = queue.poll();//父亲节点
                for(int j = 0; j < k; j++){
                    if(cur.child[j] != null){
                        res += (long)(cur.val ^ cur.child[j].val);
                        queue.add(cur.child[j]);
                    }
                }
            }
        }
        return res;
    }
}