Java面试题及其答案

最新推荐文章于 2023-02-13 14:58:37 发布

Merit_student

最新推荐文章于 2023-02-13 14:58:37 发布

阅读量185

点赞数

本文链接：https://blog.csdn.net/Merit_student/article/details/94862815

版权

1.一个圆划分为N个扇形，现用M种颜色对其上色，要求相邻两块扇形的颜色不能相同，问有多少种上色方案？（其中N>=1,M>=3)
注意：不考虑对称性，例如：一个圆划分为2个扇形，用3种颜色上色方案有“黑红，黑白，白红，白黑，红白，红黑”6种，相当于每个扇形都有编号，是不一样的。

采用数学归纳的思想。求n个扇形的上色方案，相当于在n-1个扇形中插入一个扇形，这时只需考虑两种情况：
- 1、第1个扇形和第n-1个扇形颜色不一样，这有s(n-1)种情况，此时插入的扇形n有m-2种颜色选择；
- 2、第1个扇形和第n-1个扇形颜色一样(n>3)，这有s(n-2)种情况，此时插入的扇形n有m-1种颜色选择。
- 3、如果旁边两块颜色不同那么是color(N-1,M)，那么第N块有M-2种颜色，有color(N-1,M)*（M-2）种可能；
- 4、如果旁边两块颜色相同那么是color(N-2,M)（相当于可以随便去掉第N块旁边的一块不影响讨论），那么第N块有M-1种颜色，有color(N-2,M)*（M-1）种可能；

代码：

s(1) = m;
s(2) = m(m-1);
s(3) = m(m-1)(m-2);
s(n) = s(n-1)*(m-2)+s(n-2)*(m-1);

public class circleColor {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
in.close();
if (n>=1&&m>=1){
System.out.println(color(n,m));
}

}

/**
* * @param n 扇形数
* @param m 颜色数量
* @return
*/
public static int color(int n,int m){
if(n==1){
return m;
}
if (n==2){
return m*(m-1);
}
if (n==3){
return m*(m-1)*(m-2);
}else {
return color(n-1,m)*(m-2)+color(n-2,m)*(m-1); //迭代分两种情况求和
}
}
}

2.输入一个字符串，打印字符串的全部排列

/**
* 不考虑有重复元素的全排列
*
* 基本思想是从头到尾依次选取元素，与第一个元素交换，交换之后，递归地对第一个元素之后的字符数组进行递归操作。
*/
public class StringPermutation {

   public static void permutation(char[] str, int start, int end) {

       // start == end 说明递归调用已经到头了，是输出字符串的时候了
       if (start == end) {
           for (int j = 0; j <= end; j++) {
               // 当输出字符串的时候，就看到了一直保存str的好处
               System.out.print(str[j]);
           }
           System.out.println();
       }

       for (int i = start; i <= end; i++) {

           swap(str, i, start);
           // 注意这里为了输出的方便，递归调用时，str是一直存在的，变化的是start的位置
           permutation(str, start + 1, end);
           // 交换之后，还要再交换回来，保证下一次交换之前，原来字符数组不变
           swap(str, i, start);
       }
   }

   private static void swap(char[] str, int i, int first) {
       char tmp;
       tmp = str[first];
       str[first] = str[i];
       str[i] = tmp;
   }

   public static void main(String args[]) {
       String str = "abc";
       char[] strArray = str.toCharArray();
       permutation(strArray, 0, strArray.length - 1);
   }

}

/**
* 考虑有重复元素的全排列
*
* 基本思想是从头到尾依次选取元素，与第一个元素交换，交换之后，递归地对第一个元素之后的字符数组进行递归操作。
*
* 如果后面有重复出现的元素，则这个元素只交换一次，换句话说，如果要交换start和i，则要求[str[start],str[i])里没有与str[i]相同的元素（如果有相同，说明之前已经交换过，这次就不需要交换了）
*/
public class StringPermutation {

   public static void permutation(char[] str, int start, int end) {

       // start == end 说明递归调用已经到头了，是输出字符串的时候了
       if (start == end) {
           for (int j = 0; j <= end; j++) {
               // 当输出字符串的时候，就看到了一直保存str的好处
               System.out.print(str[j]);
           }
           System.out.println();
       }

       for (int i = start; i <= end; i++) {
           if(isSwap(str, start, i)){
               swap(str, i, start);
               // 注意这里为了输出的方便，递归调用时，str是一直存在的，变化的是start的位置
               permutation(str, start + 1, end);
               // 交换之后，还要再交换回来，保证下一次交换之前，原来字符数组不变
               swap(str, i, start);
           }
       }
   }

   private static void swap(char[] str, int i, int first) {
       char tmp;
       tmp = str[first];
       str[first] = str[i];
       str[i] = tmp;
   }

   private static boolean isSwap(char[] str, int start, int toSwap){

       for(int i = start; i < toSwap; i++){
           if(str[i] == str[toSwap])
               return false;
       }
       return true;
   }

   public static void main(String args[]) {
       String str = "abb";
       char[] strArray = str.toCharArray();
       permutation(strArray, 0, strArray.length - 1);
   }

}
3.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff,则输出b.