牛客算法心得——kotori和素因子(dfs)

大家好,我是晴天学长,传智杯的题,一个经典的全排列找最小的问题,需要的小伙伴可以关注支持一下哦!后续会继续更新的。


1) .kotori和素因子


链接:https://ac.nowcoder.com/acm/problem/50042
来源:牛客网

输入
复制
4
12 15 28 22
输出
复制
17
说明
分别取3,5,7,2,可保证取出的数之和最小
示例2
输入
复制
5
4 5 6 7 8
输出
复制
-1


2) .算法思路

kotori和素因子
1.预处理2到1000的所有质数。
2.接收n个数据
3.st标记,一个数只能选一个素数

dfs(选数的位置)
1.出口,当所有数都选完了,输出结果。
2.开始选数。
3.如果没有可以选的素数了,返回-1.
4.递归到下一个选的数


3)算法步骤

1.读取输入的行并拆分为字符串数组。

2.解析数组的第一个元素为整数n,表示接下来要读取的数字个数。

3.读取下一行并将其拆分为字符串数组。

4.将字符串数组中的数字解析为整数,并存储在一个整数数组num中。

5.对num数组进行排序,以便后续处理。

6.调用get_primes方法预处理2到1000的质数,并返回质数的个数。

7.初始化一个布尔数组st,用于标记质数是否已使用。

8.调用dfs方法进行深度优先搜索,初始时传入初始参数。

9.在dfs方法中,如果搜索到叶子节点(index == length),更新最小值min。

10.对于当前数字num[index],遍历质数列表list。

11.如果当前质数list.get(i)未使用且可以整除num[index],则将该质数加入当前和sum,标记该质数为已使用,并递归调用dfs方法。

12.在递归调用dfs方法后,需要将当前质数从当前和sum中减去,并将其标记为未使用。

13.如果当前数字num[index]小于质数list.get(i),则直接返回。

14.在dfs方法结束后,如果最小值min仍然是初始值,则输出-1,否则输出最小值min。

15.实现get_primes方法,使用埃氏筛法预处理2到1000的质数,并将质数存储在列表list中。

16返回质数列表list的大小。


4). 代码实例

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main {
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static String[] lines;
    static List<Integer> list = new ArrayList<>();
    static boolean[] st;
    static int min = Integer.MAX_VALUE;

    public static void main(String[] args) throws IOException {
        lines = in.readLine().split(" ");
        int n = Integer.parseInt(lines[0]);
        lines = in.readLine().split(" ");
        int[] num = new int[n];
        for (int i = 0; i < n; i++) {
            num[i] = Integer.parseInt(lines[i]);
        }
        Arrays.sort(num);
        int lenth = get_primes(1000);

        st = new boolean[lenth];
        dfs(st, num, 0, 0, num.length);
        if (min == Integer.MAX_VALUE) System.out.println(-1);
        else System.out.println(min);
    }

    private static void dfs(boolean[] st, int[] num, int index, int sum, int length) {
        if (index == length) {
            min = Math.min(min, sum);
            return;
        }
        int temp = num[index];
        for (int i = 0; i < 168; i++) {
            if (!st[i] && temp % list.get(i) == 0) {
                sum += list.get(i);
                st[i] = true;
                dfs(st, num, index + 1, sum, length);
                st[i] = false;
                sum -= list.get(i);
            }
            if (temp < list.get(i)) return;
        }

    }

    //预处理2到1000的质数.(埃式筛)
    public static int get_primes(int n) {
        boolean[] visit = new boolean[n + 1];
        for (int i = 2; i <= n; i++) {
            if (!visit[i]) {
                list.add(i);
            }
            for (int j = i + i; j <= n; j += i) {
                visit[j] = true;
            }
        }
        return list.size();
    }
}


4).总结

  • 回溯的正常状态,一般来说,dfs上下两面都是相反的。

试题链接

你可能感兴趣的:(算法,算法,深度优先)