PTA---回溯

最新推荐文章于 2023-12-21 11:43:43 发布

wr456wr

最新推荐文章于 2023-12-21 11:43:43 发布

阅读量425

点赞数 1

分类专栏：码代码文章标签：算法回溯

本文链接：https://blog.csdn.net/wr456wr/article/details/121342489

版权

码代码专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

7-1 最佳调度问题

题目描述：

假设有n（n<=20）个任务由k（k<=20）个可并行工作的机器完成。完成任务i需要的时间为ti。试设计一个算法，对任意给定的整数n和k，以及完成任务i 需要的时间为ti ，i=1~n。计算完成这n个任务的最佳调度，使得完成全部任务的时间最早。

输入格式:
输入数据的第一行有2 个正整数n和k。第2 行的n个正整数是完成n个任务需要的时间。

输出格式:
将计算出的完成全部任务的最早时间输出到屏幕。

输入样例:
在这里给出一组输入。例如：

7 3
2 14 4 16 6 5 3

输出样例:
在这里给出相应的输出。例如：

17

在这里插入图片描述

代码：


import java.util.Scanner;
public class Main {
    static int N = 1005;
    static int n,k;
    static int []a = new int[N];
    static int []b = new int[N];
    static int ans = 0x7fffffff;
    public static void main(String[] args) {
//        System.out.println(0x7fffffff);
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        k = in.nextInt();
        for(int i = 1;i <= n;i++){
            a[i] = in.nextInt();
        }
        dfs(1,0);
        System.out.println(ans);
    }
    static void dfs(int x,int rob){
        if(rob >= ans)
            return;
        if(x > n){
            if(rob < ans)
                ans = rob;
            return;
        }
        for(int i = 1;i <= k;i++){
            if(b[i] + a[x] <= ans){
                b[i] += a[x];
                dfs(x + 1,Math.max(b[i],rob));
                b[i] -= a[x];
            }
        }
    }
}

7-2 666

题目描述：

小明有一张m*n的好习惯记录卡，记录每一天的好习惯目标达成度（数字0-9表示）。某天目标完成达成，就在当天的格子里写上数字6，目标没有完全达成就写上一个小于6的数字（0-5），目标超额完成就写上一个大于6的数字（7-9）。记录卡上如果能找到一条长度为3的路径并且路径上的三个数字都大于等于6（这里的路径是指从某个格子出发，可以向左、右、上、下格子移动，并且不能重复经过一个格子），则小明就能得到一个“666”奖励。
请你帮小明统计下他总共能得到多少“666”奖励。

输入格式:
输入第一行给出两个正整数m,n(1=<m,n<=100),随后是m行，每行包含n个0-9之间的数字。

输出格式:
先输出m行，每行包括n个整数，代表从当前格子出发得到的“666”奖励个数，中间用空格分割，最后一个数字后面不带空格。然后再在下一行输出得到的“666”奖励总数。

输入样例:

3 3
6 6 7
3 8 3
7 9 5

输出样例:

2 1 2
0 3 0
1 1 0
10

代码：

#include<iostream>

using namespace std;
int resource[102][102];//输入数组
int result[102][102];//保存结果的数组
int n, m;//m行,每行n个数

int backTrack(int i, int j, int undergoing, int direction) {//起始格子只有>=6才能进入
//i和j是起始格子的坐标，undergoing是经过的格子个数，direction表示方向，1代表向右，2代表向向下，3代表向左，4代表向上
    int number = 0, count = 0;//number表示有符合标准的解(即所经历的2个格子均>=6)，count用于记录总的解个数
    if (resource[i][j + 1] >= 6 && direction != 3) {//向右移动，且不往左移
        if (undergoing == 2) {//经过2个格子，到达第3个格子(算上自己)
            number++;
        } else {
            count += backTrack(i, j + 1, undergoing + 1, 1);//往右移，经过格子数+1
        }
    }
    if (resource[i + 1][j] >= 6 && direction != 4) {//向下移动，且不往上移
        if (undergoing == 2) {//经过2个格子，到达第3个格子(算上自己)
            number++;
        } else {
            count += backTrack(i + 1, j, undergoing + 1, 2);//往下移，经过格子数+1
        }

    }
    if (resource[i][j - 1] >= 6 && direction != 1) {//向左移动，且不往右移
        if (undergoing == 2) {//经过2个格子，到达第3个格子(算上自己)
            number++;
        } else {
            count += backTrack(i, j - 1, undergoing + 1, 3);//往左移，经过格子数+1
        }

    }
    if (resource[i - 1][j] >= 6 && direction != 2) {//向上移动，且不往下移
        if (undergoing == 2) {//经过2个格子，到达第3个格子(算上自己)
            number++;
        } else {
            count += backTrack(i - 1, j, undergoing + 1, 4);//往上移，经过格子数+1
        }

    }
    if (undergoing == 2) {
        return number;
    } else {
        return count;
    }
}
    int main() {
        int sum = 0;
        cin >> m >> n;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                cin >> resource[i][j];
            }
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (resource[i][j] >= 6)//起始格子只有>=6才能进入
                    result[i][j] = backTrack(i, j, 1, 0);
                else
                    result[i][j] = 0;
            }
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                cout << result[i][j];
                if (j != n) {//最后一个数不输出空格
                    cout << " ";
                }
                sum += result[i][j];
            }
            cout << endl;
        }
        cout << sum << endl;
        return 0;
    }

7-3 0/1背包问题

题目描述：

0/1背包问题。给定一载重量为W的背包及n个重量为wi、价值为vi的物体，1≤i≤n,要求而且重量和恰好为W具有最大的价值。

输入格式:
第一行输入背包载重量W及背包个数n，再依次输入n行，每行为背包重量wi和价值vi。

输出格式:
第一行输出装入背包内的物体编号(末尾有空格),若没有任何物品能装入，输出: No，第二行输出背包内的物体总价值。

输入样例1:

5 10
2 6
2 3
6 5
5 4
4 6

输出样例1:

1 2 5
15

在这里插入图片描述

代码：

#include<bits/stdc++.h>
using namespace std;
int n, maxw,maxv=0;
int v[101];
int w[101];
vector<vector<int>> ps;
vector<int>::iterator r;
vector<vector<int>> ::iterator t;
void power() {
	vector<vector<int>> ps1;
	vector<vector<int>>::iterator it;
	vector<int> s;
	ps.push_back(s);
	for (int i = 1;i <= n;i++) {
		ps1 = ps;
		for (it= ps1.begin();it != ps1.end();it++) {
			(*it).push_back(i);
		}
		for (it = ps1.begin();it != ps1.end();it++)
			ps.push_back(*it);
	}
}

void juddge() {
	vector<vector<int>>::iterator it;
	vector<int> :: iterator pt;
	t = ps.end();
	for (it = ps.begin();it !=ps.end();it++) {
		int sumv = 0;
		int sumw = 0;
		for (pt = (*it).begin();pt != (*it).end();pt++) {
			if (sumw + w[*pt] <= maxw) {
				sumw += w[*pt];
				sumv += v[*pt];
				if (sumv > maxv) {
					maxv = sumv;
					t = it;
				}	
			}
		}
	}
}
int main() {
	cin >> n >> maxw;
	for (int i = 1;i <= n;i++) {
		cin >> w[i] >> v[i];
	}
	power();
	juddge();
	if (t == ps.end()) {
		cout << "No"<<endl;
		cout << "0" << endl;
	}
	else {
		for (r = (*t).begin();r != (*t).end();r++) {
			cout << *r << " ";				
		}
		cout << endl;
		cout << maxv;
	}
		
}

7-4 子集和问题

问题描述：

给定n个不同的正整数集合w=（w1，w2，…，wn）和一个正数W，要求找出w的子集s，使该子集中所有元素的和为W。

输入格式:
第一行输入n和W，第二行依次输入n个数。

输出格式:
每行输出一个符合要求的子集。

输入样例1:

4 31
11 13 24 7

输出样例1:

11 13 7
24 7

在这里插入图片描述

代码：


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int w = in.nextInt();
        int []coll = new int[n];
        for(int i = 0;i < n;i++){
            coll[i] = in.nextInt();
        }
        List<Integer> list = new ArrayList<>();
        List<List<Integer>> listList = new ArrayList<>();
        dfs(list,listList,coll,0,0,w);
        for(int i = 0;i < listList.size();i++){
            for(int j = 0;j < listList.get(i).size();j++){
                System.out.print(listList.get(i).get(j) + " ");
            }
            System.out.println();
        }
    }
    static void dfs(List<Integer> list,List<List<Integer>> listList,int []coll,int index,int count,int target){
        if(target == count){
            listList.add(new ArrayList<>(list));
            return;
        }
        if(count > target){
            return;
        }
        for(int i = index;i < coll.length;i++){
            list.add(coll[i]);
            dfs(list,listList,coll,i + 1,count + coll[i],target);
            list.remove(list.size() - 1);
        }

    }
}