CF gym100851B-Generators/POJ1018-Communication System

暴力最优化问题处理：

CF gym100851B-Generators

题意：给定一个生成随机数序列的公式，xi+1 = (axi + b) mod c，给定n组参数，求出在每个生成的序列中选出的数的的最大值，该数不被k整除。

 

分析：首先根据参数求出给出的n个序列，既然是要选最大的，那么从大到小排序。首先令ans为各个序列最大的数之和。如果k整除ans怎么办呢？看似好像很难去找最大的了，因为不知道怎么选择不被k整除的且又是最大的数。其实很容易处理，既然这样，那么可以从n个序列中将最大值换为能够选取的次优解，如果要求最优解的话，那么只更换一组即可（更换多组显然没有更换一组更优），而且每组如果要更换，那么只能更换为那个与最大值差值不是k的倍数的次优解，其他组不更换即可，那么直接暴力即可，选取最大的并记录位置就行了。

刚开始做的时候没有深入思考，在k整除ans的情况下以为不好处理，其实根本就没必要枚举很多，只要每个序列求解一次次优解即可，次优解的选取必须满足一个条件，与最优解的差值不是k的倍数。直接暴力就行了，这种题没有什么更好的处理办法。

还是那句话：思维上要有广搜起点，深搜终点的觉悟！！！

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

typedef pair<int, int> p;
vector<p> seq[10005];
int vis[1010], pos[10005];
int ans;
int main()
{
    freopen("generators.in", "r", stdin);
    freopen("generators.out", "w", stdout);
    int n, k;
    scanf("%d %d", &n, &k);
    for (int i = 0; i < n; i++){
        int x, a, b, c;
        scanf("%d %d %d %d", &x, &a, &b, &c);
        memset(vis, 0, sizeof(vis));
        seq[i].push_back(p(x, 0));
        vis[x] = 1;
        int t = x, j = 1;
        while (1){
            t = (t * a + b) % c;
            if (vis[t]) break;
            else vis[t] = 1, seq[i].push_back(p(t, j++));
        }
        sort(seq[i].begin(), seq[i].end(), greater<p>());
        pos[i] = seq[i][0].second; ans += seq[i][0].first;
    }
    if (ans % k == 0){
        int t = ans;
        ans = -1;
        int id = 0, res = 0;
        for (int i = 0; i < n; i++){
            for (int j = 1; j < seq[i].size(); j++){
                int tm = t - seq[i][0].first + seq[i][j].first;
                if (tm % k){
                    if (tm > ans){
                        ans = tm;
                        id = i;
                        res = seq[i][j].second;
                    }
                    break;
                }
            }
        }
        pos[id] = res;
    }
    printf("%d\n", ans);
    if (ans != -1)
        for (int i = 0; i < n; i++) printf("%d%c", pos[i], i == n-1 ? '\n' : ' ');
    return 0;
}

这题和poj上一个题很相似：

POJ1018-Communication System

题意：有n个设备要选取，每个设备由多个厂家提供，设备有两个属性，b和p，在每个设备对应的制造商中分别选取一种，定义B为所选取的设备中b的最小值，P为所选出的设备中p的总和，求出B/P的最大值。

分析：首先考虑贪心策略，枚举量大大减少，局部最优没有是整体最优，必然错误，这题没有什么其他的好的处理办法，暴力即可。但是怎么枚举呢？

对于这种选取方案受多个值约束的情况，有两种方式处理：1、根据题意进行转化，将两者合二为一化归为对等价问题的判断。2、固定一者，然后枚举另一者处理。

那么这题当中，我们可以固定所有设备的b的最小值为i，每次在对应的制造商中选取大于等于i的最小的p，对于n种设备，每个设备有对应的最小的b和最大的b，那么从最小的b当中的最小者枚举到最大的b当中的最小者就可以了，对于本题其实还有一个优化，在对i进行枚举时，可以先按b由大到小排序，那么p只需要枚举到那个大于等于i的地方就行了，但是本题数据量很小，优化不是很明显。

 

#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

int num[110], devb[110][110], devp[110][110];

int main()
{
    int n, k;
    scanf("%d", &k);
    while (k--){
        scanf("%d", &n);
        for (int i = 0; i < n; i++){
            scanf("%d", &num[i]);
            for (int j = 0; j < num[i]; j++) scanf("%d %d", &devb[i][j], &devp[i][j]);
        }
        int a, b;
        a = b = INF;
        for (int i = 0; i < n; i++){
            a = min(a, *min_element(devb[i], devb[i]+num[i]));
            b = min(b, *max_element(devb[i], devb[i]+num[i]));
        }
        double ans = 0;
        for (int i = a; i <= b; i++){
            int sum = 0;
            for (int j = 0; j < n; j++){
                int p = INF;
                for (int x = 0; x < num[j]; x++)
                    if (devb[j][x] >= i && devp[j][x] < p) p = devp[j][x];
                sum += p;
            }
            ans = max(ans, (i+0.0)/sum);
        }
        printf("%.3f\n", ans);
    }
    return 0;
}

从以上两题可以看出，对于类似这种暴力枚举最优化问题的处理，其实都是有一定的技巧或者原则来处理的，需要根据题目给出的条件和背景分析得出，也算是一种贪心的枚举策略吧。