算法设计与分析--搜索算法

回溯算法

回溯算法也叫试探算法，是一种系统的搜索问题解的方法。回溯法可以看做是递归的一种特殊形式。

在回溯时，应当：保存当前步骤，如果是一个解就输出，维护状态，使搜索路径尽量不重复（体现在记录当期数据是否被访问）。必要时，应该对不可能的解进行剪枝。回溯法可以被认为是一个有过剪枝过程的DFS

 

 

 

子集和问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description

子集和问题的一个实例为〈S,t〉。其中，S={  x1 ， x2 ，…，xn }是一个正整数的集合，c是一个正整数。子集和问题判定是否存在S的一个子集S1，使得：
。
试设计一个解子集和问题的回溯法。
对于给定的正整数的集合S={  x1 ， x2 ，…，xn }和正整数c，计算S 的一个子集S1，使得：
。

Input

输入数据的第1 行有2 个正整数n 和c（n≤10000，c≤10000000），n 表示S 的大小，c是子集和的目标值。接下来的1 行中，有n个正整数，表示集合S中的元素。

Output

将子集和问题的解输出。当问题无解时，输出“No Solution!”。

Sample Input

5 10
2 2 6 5 4

Sample Output

2 2 6

#include <bits/stdc++.h>
using namespace std;

int n, c, ans[10010], v[10010], a[10010], flag = 0;

void dfs(int temp)
{
    if(flag) return;
    for(int i = 0; i < n; i++)
    {
        if(v[i] == 0 && c >= 0)
        {
            if(c - a[i] >= 0)
            {
                v[i] = 1;
                c -= a[i];
                ans[temp] = a[i];
                if(c == 0)
                {
                    for(int j = 0; j <= temp; j++)  // 注意j<=temp, 因为递归是从0开始，这个不是数组含义
                    {
                        if(j == 0)
                            printf("%d", ans[j]);
                        else
                            printf(" %d", ans[j]);
                    }
                    printf("\n");
                    flag =1;
                    return;
                }
                else  // 不等于0时，继续进行递归
                    dfs(temp + 1);
                if(flag == 1) return;  // 记得判断一下
                c += a[i];  // 条件清空
                v[i] = 0;
            }
        }
    }
}

int main()
{
    int sum = 0;
    cin>>n>>c;
    for(int i = 0; i < n; i++)
    {
        cin>>a[i];
        sum += a[i];
    }
    if(sum < c)
    {
        printf("No Solution!\n");
        return 0;
    }
    memset(ans, 0, sizeof(ans));
    memset(v, 0, sizeof(v));
    dfs(0);  // 从0开始
    if(flag == 0)
        printf("No Solution!\n");
    return 0;
}

 

工作分配问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description

设有n件工作分配给n个人。将工作i分配给第j个人所需的费用为 cij。试设计一个算法，为每一个人都分配1 件不同的工作，并使总费用达到最小。
设计一个算法，对于给定的工作费用，计算最佳工作分配方案，使总费用达到最小。

Input

输入数据的第一行有1 个正整数n (1≤n≤20)。接下来的n行，每行n个数，表示工作费用。

Output

将计算出的最小总费用输出。

Sample Input

3
10 2 3
2 3 4
3 4 5

Sample Output

9

#include <bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f

int ans, sum, a[25][25], vis[25] = {0}, n;

void dfs(int i, int sum)
{
    if(sum < ans && i >= n)
    {
        ans = sum;
        return;
    }
    if(sum < ans)  // 注意这个判断条件
    {
        for(int j = 0; j < n; j++)
        {
            if(vis[j] == 0)
            {
                vis[j] = 1;
                dfs(i + 1, sum + a[i][j]);
                vis[j] = 0;  // 清空标志位
            }
        }
    }
}

int main()
{
    cin>>n;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            cin>>a[i][j];
        }
    }
    ans = INF;  // 赋值 最大值
    dfs(0, 0);  // 都是从0开始输入数组的，所以从0开始
    printf("%d\n", ans);
    return 0;
}

 

整数变换问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description

整数变换问题。关于整数i的变换f和g定义如下：f(i)=3i；
试设计一个算法，对于给定的2 个整数n和m，用最少的f和g变换次数将n变换为m。例如，可以将整数15用4 次变换将它变换为整数4：4=gfgg(15)。当整数n不可能变换为整数m时，算法应如何处理?
对任意给定的整数n和m，计算将整数n变换为整数m所需要的最少变换次数。

Input

输入数据的第一行有2 个正整数n和m。n≤100000，m≤1000000000。

Output

将计算出的最少变换次数以及相应的变换序列输出。第一行是最少变换次数。第2 行是相应的变换序列。

Sample Input

15 4

Sample Output

4
gfgg

Hint

#include<iostream>
using namespace std;

int k=1;
int c=0;//用来记录字符数组位置
char a[100] = {'\0'};//用来存放变换序列

int select(int n,int m,int s)
{
    if(s==0)
        return 3*n;
    else
        return n/2;
}

bool dfs(int step,int n,int m)
{
    int num;
    if(step>k)
        return false;
    num=n;
    for(int i=0;i<2;i++)
    {
        num=select(n,m,i);
        if(num==m||dfs(step+1,num,m))
        {
            if(i==0)
                a[c]='f';
            else
                a[c]='g';
            c++;
            return true;
        }
    }
    return false;
}

int main()
{
    int m,n;
    cin>>n>>m;
    k = 1;
    while(!dfs(1,n,m))
        k++;
    cout<<k<<endl;
    //int i=0;
    for(int i=0;i<c;i++)
        cout<<a[i];
    return 0;
}

 

 

运动员最佳匹配问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

羽毛球队有男女运动员各n 人。给定2 个n×n 矩阵P 和Q。P[i][j]是男运动员i 和女运动员j配对组成混合双打的男运动员竞赛优势；Q[i][j]是女运动员i和男运动员j配合的女运动员竞赛优势。由于技术配合和心理状态等各种因素影响，P[i][j]不一定等于Q[j][i]。男运动员i和女运动员j配对组成混合双打的男女双方竞赛优势为P[i][j]*Q[j][i]。
设计一个算法，计算男女运动员最佳配对法，使各组男女双方竞赛优势的总和达到最大。
设计一个算法，对于给定的男女运动员竞赛优势，计算男女运动员最佳配对法，使各组男女双方竞赛优势的总和达到最大。

Input

输入数据的第一行有1 个正整数n (1≤n≤20)。接下来的2n 行，每行n个数。前n行是p，后n行是q。

Output

将计算出的男女双方竞赛优势的总和的最大值输出。

Sample Input

3
10 2 3
2 3 4
3 4 5
2 2 2
3 5 3
4 5 1

Sample Output

52

Hint

 

#include <bits/stdc++.h>

using namespace std;

int n, ans, a[22][22], b[22][22], vis[22], pre[22];

void dfs(int x, int s)  // 和明显，X是类似于累加的次数，应该和n进行比较，s是最终结果的东西
{
    if(x > n)  // x与n进行比较
    {
        ans = max(ans, s);
        return;
    }
    if(s + pre[n] - pre[x - 1] < ans)  // n 和 x - 1
        return;
    for(int i = 1; i <= n; i++)
    {
        if(!vis[i])
        {
            vis[i] = 1;
            dfs(x + 1, s + a[x][i] * b[i][x]);  // 注意是a*b
            vis[i] = 0;
        }
    }
}

int main()
{
    cin>>n;
    for(int i = 1; i <= n; i++)
        for(int j  =1; j <= n; j++)
        cin>>a[i][j];

    for(int i = 1; i <= n; i++)
        for(int j  =1; j <= n; j++)
        cin>>b[i][j];

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
          pre[i] = max(pre[i], a[i][j] * b[j][i]);  // a b 进行计算
        }
        pre[i] += pre[i - 1];
    }
    dfs(1, 0);  // 1 0
    cout<<ans<<endl;
    return 0;
}