算法竞赛入门经典(第二版)-刘汝佳-第七章 暴力求解法 例题（6/15）

说明

本文是我对第七章15道例题的练习总结，建议配合紫书——《算法竞赛入门经典（第2版）》阅读本文。
另外为了方便做题，我在VOJ上开了一个contest，欢迎一起在上面做：第七章例题contest
如果想直接看某道题，请点开目录后点开相应的题目！！！

例题

例7-1 UVA 725 除法

题意
输入正整数n，按从小到大的顺序输出所有形如abcde/fghij = n的表达式，其中a～j恰好为数字0～9的一个排列（可以有前导0），2≤n≤79。
思路
枚举0～9的所有排列？没这个必要。只需要枚举fghij就可以算出abcde，然后判断是否所有数字都不相同即可。不仅程序简单，而且枚举量也从10!=3628800降低至不到1万，而且当abcde和fghij加起来超过10位时可以终止枚举。由此可见，即使采用暴力枚举，也是需要认真分析问题的。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int n;
int arr[2][5];
int ans;

void get_arr(int a[], int num)
{
    for (int i = 4; i > 0; i --) {
        a[i] = num%10;
        num /= 10;
    }
    a[0] = num;
}

bool check()
{
    int cnt[10] = {0};
    for (int i = 0; i < 2; i ++) {
        for (int j = 0; j < 5; j ++) {
            if (arr[i][j] >= 10 || ++cnt[arr[i][j]] > 1) return false;
        }
    }
    return true;
}

void print()
{
    for (int i = 0; i < 5; i ++)
        printf("%d", arr[0][i]);
    printf(" / ");
    for (int i = 0; i < 5; i ++)
        printf("%d", arr[1][i]);
    printf(" = %d\n", n);
}

int main(void)
{
    int t = 0;
    while (cin >> n && n) {
        if (t++) puts("");
        ans = 0;
        for (int y = 1234; y <= 50000; y++) {
            int x = y * n;
            get_arr(arr[0], x);
            get_arr(arr[1], y);
            if (check()) {
                ans++;
                print();
            }
        }
        if (!ans) printf("There are no solutions for %d.\n", n);
    }

    return 0;
}

例7-2 UVA 11059 最大乘积

题意
输入n个元素组成的序列S，你需要找出一个乘积最大的连续子序列。如果这个最大的乘积不是正数，应输出0（表示无解）。1≤n≤18，-10≤Si≤10。
样例输入：
3
2 4-3
5
2 5 -1 2 -1
样例输出：
8
20
思路
连续子序列有两个要素：起点和终点，因此只需枚举起点和终点即可。由于每个元素的绝对值不超过10且不超过18个元素，最大可能的乘积不会超过1018，可以用long long存储。

这个题还可以用DP来做，时间复杂度将从O(N^2)降成O(N)。当然这是后话了。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 18;

int main(void)
{
    int t = 0;
    int n, a[N];

    while (scanf("%d", &n) != EOF && n) {
        for (int i = 0; i < n; i ++)
            scanf("%d", &a[i]);

        long long res = a[0];
        for (int i = 0; i < n; i ++) {
            long long mult = 1;
            for (int j = i; j < n; j ++) {
                mult *= a[j];
                res = max(mult, res);
            }
        }
        if (res < 0) res = 0;
        printf("Case #%d: The maximum product is %lld.\n\n", ++t, res);
    }

    return 0;
}

例7-3 UVA 10976 分数拆分

题意
输入正整数k，找到所有的正整数x≥y，使得1/k=1/x+1/y.
思路
既然要求找出所有的x、y，枚举对象自然就是x、y了。可问题在于，枚举的范围如何？从1/12=1/156+1/13可以看出，x可以比y大很多。难道要无休止地枚举下去？当然不是。由于x≥y，有1/x≤1/y，因此1/k-1/y≤1/y，即y≤2k。这样，只需要在2k范围之内枚举y，然后根据y尝试计算出x即可。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

int main(void)
{
    int k, x, y;

    while (scanf("%d", &k) != EOF) {
        int cnt = 0;
        typedef pair<int, int> P;
        vector<P> res;
        for (y = k+1; y <= 2*k; y ++) {
            x = k*y;
            if (x % (y-k) == 0) {
                x /= (y-k);
                cnt ++;
                res.push_back(P(x, y));
            }
        }
        printf("%d\n", cnt);
        for (int i = 0; i < cnt; i ++)
            printf("1/%d = 1/%d + 1/%d\n", k, res[i].first, res[i].second);
    }

    return 0;
}

例7-4 UVA 524 素数环

题意
输入正整数n，把整数1, 2, 3,…, n组成一个环，使得相邻两个整数之和均为素数。输出时从整数1开始逆时针排列。同一个环应恰好输出一次。n≤16。
思路
如果最坏情况下的枚举量很大，应该使用回溯法而不是生成-测试法。
代码

#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;

int isPrime(int n)
{
    for (int i=2; i<=sqrt(n); i++)
    {
        if (n%i == 0)
            return 0;
    }
    return 1;
}

int p[40];

void initPrime()
{
    int i;
    p[1] = 0;
    for (i=2; i<32; i++)
    {
        if (isPrime(i))
            p[i] = 1;
        else
            p[i] = 0;
    }
}

void printPrime()
{
    int i;
    for (i=1; i<=39; i++)
        printf("%d ", p[i]);
    printf("\n");
}

int b[17][17];

void initBeside()
{
    int i, j;
    for (i=1; i<17; i++)
    {
        b[i][0] = 0;
        for (j=1; j<17; j++)
        {
            if (j!=i && p[i+j])
                b[i][++b[i][0]] = j;
        }
    }
}

void printBeside()
{
    int i, j;
    for (i=1; i<=6; i++)
    {
        int tmp = b[i][0];
        for (j=1; j<=tmp; j++)
            printf("%d ", b[i][j]);
        printf("\n");
    }
}

int n;
int v[17];
int num[17];

void initSet()
{
    memset(v, 0, sizeof(v));
    v[1] = 1;
    num[1] = 1;
}

void printCircle()
{
    int i;
    for (i=1; i<n; i++)
        printf("%d ", num[i]);
    printf("%d\n", num[i]);
}

void set(int k)
{       
    if (k == n)
    {   
        if (p[num[n]+num[1]])
            printCircle();
        return;
    }
    int i;
    int x = num[k];
    int count = b[x][0];
    for (i=1; i<=count; i++)
    {
        int tmp = b[x][i];
        if (tmp > n)
            break;
        if (!v[tmp])
        {   
            num[k+1] = tmp;
            v[tmp] = 1;
            set(k+1);
            v[tmp] = 0;
        }
    }
}

int main(void)
{
    initPrime(); 
    //printPrime();
    initBeside();
    //printBeside();

    int count = 0;
    while (scanf("%d", &n) != EOF)
    {   
        if (count) printf("\n");
        printf("Case %d:\n", ++count);
        initSet();
        set(1);
    }

    return 0;
}

例7-5 UVA 129 困难的串

题意
如果一个字符串包含两个相邻的重复子串，则称它是“容易的串”，其他串称为“困难的串”。例如，BB、ABCDACABCAB、ABCDABCD都是容易的串，而D、DC、ABDAB、CBABCBA都是困难的串。
输入正整数n和L，输出由前L个字符组成的、字典序第k小的困难的串。例如，当L=3时，前7个困难的串分别为A、AB、ABA、ABAC、ABACA、ABACAB、ABACABA。输入保证答案不超过80个字符。
思路
基本框架不难确定：从左到右依次考虑每个位置上的字符。因此，问题的关键在于如何判断当前字符串是否已经存在连续的重复子串。例如，如何判断ABACABA是否包含连续重复子串呢？一种方法是检查所有长度为偶数的子串，分别判断每个字串的前一半是否等于后一半。尽管是正确的，但这个方法做了很多无用功。还记得八皇后问题中是怎么判断合法性的吗？判断当前皇后是否和前面的皇后冲突，但并不判断以前的皇后是否相互冲突——那些皇后在以前已经判断过了。同样的道理，我们只需要判断当前串的后缀，而非所有子串。
提示：在回溯法中，应注意避免不必要的判断，就像在八皇后问题中那样，只需判断新皇后和之前的皇后是否冲突，而不必判断以前的皇后是否相互冲突。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;

int m, k;
int cnt;

void print_hard(string s)
{
    int n = s.size();
    for (int i = 0; i < n; i++) {
        if (i % 4 == 0) {
            if (i % 64 != 0)
                printf(" ");
            else if (i)
                printf("\n");
        }
        printf("%c", s[i]);
    }
    printf("\n%d\n", n);
}

void find_hard(string s)
{
    int n = s.size();
    for (int i = 0; i < k; i++) {
        if (cnt >= m) break;
        char c = i+'A';
        bool flag = true;
        for (int j = 1; j <= (n+1)/2; j++) {
            if (s.substr(n-j+1)+c == s.substr(n+1-j*2, j)) {
                flag = false;
                break;
            }
        }
        if (flag) {
            if (++cnt == m) {
                print_hard(s+c);
                return;
            }
            find_hard(s+c);
        }
    }
}

int main(void)
{
    while (scanf("%d%d", &m, &k), m || k) {
        cnt = 0;
        find_hard("");
    }

    return 0;
}

例7-6 UVA 140 带宽

题意
给出一个n（n≤8）个结点的图G和一个结点的排列，定义结点i的带宽b(i)为i和相邻结点在排列中的最远距离，而所有b(i)的最大值就是整个图的带宽。给定图G，求出让带宽最小的结点排列.
思路
如果不考虑效率，本题可以递归枚举全排列，分别计算带宽，然后选取最小的一种方案。能否优化呢？和八皇后问题不同的是：八皇后问题有很多可行性约束（feasibility constraint），可以在得到完整解之前避免扩展那些不可行的结点，但本题并没有可行性约束——任何排列都是合法的。难道只能扩展所有结点吗？当然不是。
可以记录下目前已经找到的最小带宽k。如果发现已经有某两个结点的距离大于或等于k，再怎么扩展也不可能比当前解更优，应当强制把它“剪”掉，就像园丁在花园里为树修剪枝叶一样，也可以为解答树“剪枝（prune）”。
除此之外，还可以剪掉更多的枝叶。如果在搜索到结点u时，u结点还有m个相邻点没有确定位置，那么对于结点u来说，最理想的情况就是这m个结点紧跟在u后面，这样的结点带宽为m，而其他任何“非理想情况”的带宽至少为m+1。这样，如果m≥k，即“在最理想的情况下都不能得到比当前最优解更好的方案”，则应当剪枝。
提示：在求最优解的问题中，应尽量考虑最优性剪枝。这往往需要记录下当前最优解，并且想办法“预测”一下从当前结点出发是否可以扩展到更好的方案。具体来说，先计算一下最理想情况可以得到怎样的解，如果连理想情况都无法得到比当前最优解更好的方案，则剪枝。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;

vector<int> neigh[26];
int n;
int node[8];

int resd = 26;
vector<int> vmin;

void choose(int m, int a[], bool used[], int pos[], int curd)
{
    if (m == n) {
        if (curd < resd) {
            resd = curd;
            vmin.clear();
            for (int i = 0; i < n; i++)
                vmin.push_back(a[i]);
        }
    }
    for (int i = 0; i < n; i++) {
        int k = node[i];
        if (!used[k]) {
            int maxd = curd;
            for (int j = 0; j < neigh[k].size(); j++) {
                int r = neigh[k][j];
                if (used[r])
                    maxd = max(maxd, abs(m - pos[r]));
            }
            if (maxd < resd) {
                a[m] = k;
                used[k] = 1;
                pos[k] = m;
                choose(m+1, a, used, pos, maxd);
                used[k] = 0;
            }
        }
    }
}

int main(void)
{
    char ch;
    while ((ch = getchar()) != '#') {
        for (int i = 0; i < 26; i++)
            neigh[i].clear();
        bool used[26];
        memset(used, 0, sizeof(used));
        do {
            int i = ch-'A';
            used[i] = 1;
            getchar();
            while ((ch = getchar()) != ';' && ch != '\n') {
                int j = ch-'A';
                neigh[i].push_back(j);
                neigh[j].push_back(i);
                used[j] = 1;
            }
            if (ch == '\n') break;
        } while (ch = getchar());
        n = 0;
        for (int i = 0; i < 26; i++) {
            if (used[i]) node[n++] = i;
        }

        int a[8], pos[26];
        memset(used, 0, sizeof(used));
        resd = 26;
        choose(0, a, used, pos, 0);

        for (int i = 0; i < n; i++)
            printf("%c ", vmin[i]+'A');
        printf("-> %d\n", resd);
    }

    return 0;
}

例7-7 UVA 1354 天平难题

题意

思路

代码

例7-8 UVA 10603 倒水问题

题意

思路

代码

例7-9 UVA 1601 万圣节后的早晨

题意

思路

代码

例7-10 UVA 11212 编辑书稿

题意

思路

代码

例7-11 UVA 12325 宝箱

题意

思路

代码

例7-12 UVA 1343 旋转游戏

题意

思路

代码

例7-13 UVA 1374 快速幂计算

题意

思路

代码

例7-14 UVA 1602 网格动物

题意

思路

代码

例7-15 UVA 1603 破坏正方形

题意

思路

代码