笔试强训第9天

选择题

• System.arraycopy是浅拷贝
• clone方法，对于数组是浅拷贝，对于对象是深拷贝 

• 包装类在进行数学运算的时候，会自动拆箱 

编程题 

import java.util.*;

public class UnusualAdd {
    public int addAB(int A, int B) {
        if(B==0){
            return A;
        }
        // write code here
        while (B!=0){
           int sum=A^B;
           int carray=(A&B)<<1;
           A=sum;
           B=carray;
        }
        return A;
    }
}

 

 

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        System.out.println(getStep(n,m));
    }
    public static int  getStep(int n,int m){
        if(n==0||m==0){
            return 1;
        } else {
            return getStep(n-1,m)+getStep(n,m-1);
        }
    }

}

• 如果数据比较小，用递归就可以，如果数据比较大，用动态规划
• 递归方法的时间复杂度是O(2^n)

 

动态规划

import java.util.Scanner;
public class Main {
       public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int dp[][]=new  int[n+1][m+1];//dp[i][j]表示到ij下标的步数
        for (int i = 0; i <=n; i++) {
            for (int j = 0; j <=m; j++) {
                if (i==0||j==0){
                    //base case
                    dp[i][j]=1;
                }else {
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                    //状态转换方程
                }
            }
        }
        System.out.println(dp[n][m]);

    }


}

• 动态规划的时间复杂度是O(n*m)