【Java版oj】day30最难的问题、因子个数

目录

 一、最难的问题

（1）原题再现

（2）问题分析

（3）完整代码

 二、因子个数

（1）原题再现

（2）问题分析

（3）完整代码

三、DFS深度优先列举所有可能的情况

---

 一、最难的问题

（1）原题再现

最难的问题__牛客网

        NowCoder生活在充满危险和阴谋的年代。为了生存，他首次发明了密码，用于军队的消息传递。假设你是军团中的一名军官，需要把发送来的消息破译出来、并提
供给你的将军。
        消息加密的办法是：对消息原文中的每个字母，分别用该字母之后的第5个字母替换（例如：消息原文中的每个字母A 都分别替换成字母F），其他字符不 变，并且消息原文的所有字母都是大写的。密码中的字母与原文中的字母对应关系如下。
密码字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
原文字母：V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

 

输入描述:

输入包括多组数据，每组数据一行，为收到的密文。

密文仅有空格和大写字母组成。

 

输出描述:

对应每一组数据，输出解密后的明文。

示例1

输入

HELLO WORLD

SNHJ

输出

CZGGJ RJMGY

NICE

（2）问题分析

     这道题没什么难度，就是一个简单的查找对应问题。用两个数组分别存储明文和密文，下标一一对应查找一下就可以。

（3）完整代码

import java.util.*;
/*
 * 最难的问题
 */
public class Main {
	static char[]strArr= {'A', 'B','C','D','E','F','G','H','I','J',
			'K','L','M','N','O','P','Q','R','S','T',
			'U','V','W','X','Y','Z'};
	static char[]resArr= {'V','W','X','Y','Z','A', 'B','C','D','E','F','G','H','I','J',
			'K','L','M','N','O','P','Q','R','S','T','U'};
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNextLine()) {
			String str=sc.nextLine();
			StringBuilder sb=new StringBuilder();
			
			for(int i=0;i<str.length();i++) {
				int index=myIndexOf(str.charAt(i), strArr);
				if(index!=-1) {
					sb=sb.append(resArr[index]);
				}else {
					sb=sb.append(str.charAt(i));
				}
			}
			System.out.println(sb.toString().trim());
		}
	}
	public  static int myIndexOf(char c,char[]str) {
		for(int i=0;i<str.length;i++ ) {
			if(c==str[i]) {
				return i;
			}
		}
		return -1;
	}
}

 二、因子个数

（1）原题再现

因子个数__牛客网

        一个正整数可以分解成一个或多个数组的积。例如36=2*2*3*3，即包含2和3两个因子。NowCoder最近在研究因子个数的分布规律，现在给出一系列正整数，他希望你开发一个程序输出每个正整数的因子个数。

 

输入描述:

输入包括多组数据。

每组数据仅有一个整数n (2≤n≤100000)。

 

输出描述:

对应每个整数，输出其因子个数，每个结果占一行。

示例1

输入

30

26

20

输出

3

2

2

（2）问题分析

       我首先想到的DFS深度优先算法，把所有组合情况列举出来，但是会造成超时错误。我会把DFS的代码放到文末，有兴趣的同学可以感受一下深度优先的魅力。

        其实这道题其实可以很简单。从最小因子2到数字的最大因子数即数字的平方根开始判断是否能够取余，可以则循环取余直到取余不为0，因子个数+1；否则使用下一个因子计算；最终整除了各个因子数之后剩余的数字不为1则本身也是一个因子，因此因子数+1。

（3）完整代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            int count = 0;
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) {
                    while (n % i == 0) {
                        n /= i;
                    }
                    count++;
                }
            }
            if (n != 1) {
                count++;
            }
            System.out.println(count);
        }
    }
}

​

三、DFS深度优先列举所有可能的情况

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
/*
 * 因子个数
 */
//超时但是结果都对
public class NumberOfFactors {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {      
        	 int num = sc.nextInt();
            List <Integer>list = new LinkedList<>();
            for (int i = 1; i <= num; i++) { //1~num有多少个质数
                int temp = isFactor(i);
                if (temp != -1) { //是质数加入列表
                    list.add(temp);
                }
            }

            List<Integer>one = new LinkedList<>();
            List<List<Integer>>res = new LinkedList<>();
            DFS(0, num, 1, list, one, res);
           int min=Integer.MAX_VALUE;
           int tmp=0;
           int i=0;
            for (i = 0; i < res.size(); i++) {
            	if(min>res.get(i).size()) {
            		min=res.get(i).size();
            		tmp=i;//保存长度最小的组合链表的下标（其实就一种）
            	}
            }
//其实这里有个小bug,链表长度最短的不代表因子数就是最少的！
//但是其实我们可以不用管，做完之后就会发现，每个res结果集中只会有一种组合，根本不存在多种可能。
            Set<Integer> set=new HashSet<>();//用set集合达到去重的效果，比如8=2*2*2*2;因子数为1
            for(int j=0;j<res.get(tmp).size();j++) {
            	set.add(res.get(tmp).get(j));
            }
            System.out.print(set.size()+" ");
        }
    }
    public static void DFS(int index, int num, int mulRes, List<Integer>list,List<Integer> one, List<List<Integer>> res) {
        //num目标值,list所有比num小的质数集合，one存放一种正确的组合，res结果集合;每一种正确的组合都放进结果集，mulRes当前的数，index下标位置
        if (mulRes > num) {
            return;//当前值大于目标值就返回
        }
        if (mulRes == num) {//当前值等于目标值，表示这个组合正确，是我们想要的
            List<Integer> temp = new
            LinkedList<>(); //临时变量，将一种组合放入结果集
            for (int i = 0; i < one.size(); i++) {
                temp.add(one.get(i));
            }
            res.add(temp);
            return;
        }
        for (int i = index; i < list.size(); i++) {
            if (mulRes > num) {
                continue;//如果当前值大于目标值就下一个，但是本题按顺序排的不会出现这种情况，可以不写
            }
            one.add(list.get(i));
            DFS(i, num, mulRes * list.get(i), list, one, res);
            one.remove(one.size() -1); //回溯，当前值如果大于等于就要回到上一步，然后不合适的质数删去走下一步
        }
    }
    public static int isFactor(int num) {//判断某个数是否为质数
        if (num == 1) {
            return -1;
        }
        if (num == 2) {
            return 2;
        }
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                return -1;//不是返回-1
            }
        }
        return num;//是返回该值
    }
}

---