2014 清华集训 day2

T1--------------------------------------------------------------------------------------------

简单回路

Description

在一个有障碍点的 n 行 m 列的网格图中，我们用 (x,y) 来表示第 x 行第 y 列的格子。如果该网格图中的回路满足下面两个条件：

不经过任何一个障碍点

回路不自交

则我们称该回路为合法的简单回路。

现在有 Q 个询问，每次询问有多少条合法的简单回路经过了 (x,y) 与 (x+1,y) 之间的边。

Input

第一行输入三个非负整数 n, m，k，表示 n 行 m 列的网格图中有 k 个障碍点。

接下来 k 行，每行两个正整数x,y (1≤x≤n,1≤y≤m)，表示 (x,y) 为一个障碍点（可能重复）

接下来一个整数 Q，表示 Q 个询问。

接下来 Q 行，每行两个正整数 x,y (1≤x≤n−1,1≤y≤m)，询问有多少条合法的简单回路经过了格子 (x,y) 与 (x+1,y) 之间的边。

Output

输出 Q 行，每行对应一组询问。请将答案 mod(1000000000+7) 之后输出。

Sample Input

 

4 4 4
2 2
2 4
3 2
4 4
4
1 1
1 4
3 3
2 2

Sample Output

 

1
0
1
0

HINT

 

 

应该是插头DP，表示不会打，暴力搞搞30分

CODE:

#include <iostream>
#include <cstdio>
#include <cstring>
#define REP(i, s, n) for(int i = s; i <= n; i ++)
#define REP_(i, s, n) for(int i = n; i >= s; i --)
#define MAX_N 10000 + 10
#define mod 1000000000 + 7

using namespace std;

int n, m, k, q;
int map[MAX_N][MAX_N];

int main(){
    scanf("%d%d%d", &n, &m, &k);
    int x, y; memset(map, 0, sizeof(map));
    REP(i, 1, k){
        scanf("%d%d", &x, &y);
        map[y][x] = 1;
    }    
    REP(i, 1, m) map[i][0] = map[i][n + 1] = 1;
    if(m == 1){
        scanf("%d", &q);
        while(q --){
            int x, y; scanf("%d%d", &x, &y);
            printf("0\n");
        }
    }
    else if(m == 2){
        scanf("%d", &q);
        while(q --){
            int x, y; scanf("%d%d", &y, &x);
            int tmp = y, l, r;
            while((!map[1][tmp]) && (!map[2][tmp])) tmp --;
            l = y - tmp; tmp = y + 1;
            while((!map[1][tmp]) && (!map[2][tmp])) tmp ++;
            r = tmp - (y + 1);
            cout << l * r << endl;
        }
    }    
    return 0;
}

 

T2----------------------------------------------------------------------------------------------------------------------------------------------

卡常数

Description

在某个诡异的地方，有一座智慧之城，那里的人民平均智商 为 192，智商低于 150 的人都被称为弱智。智慧之城的市长名叫卡常（Karp-de-Chant），他 12 岁时在智慧之城中心大学 Cross Institute 获得博士学位，两年后发明了一种数列 —— 卡常数（Karp-de-Chant Number），该数列可用来解决或优化数论、图论等领域的多种经典难题。后来，卡常数被 Trajan（智慧之城的副市长）用 spaly 树进行扩展后，威力大大增加，可以在线性时间内解决各种网络流问题和其它一些难题。卡常和 Trajan 因此分别被选为正、副市长，他们和智慧之城内的另一些智者一起，领导人民共同建设人类智慧，发挥创造和改进的能力。

然而某一天，智慧之城突然受到了反人类智慧者的袭击，反人类智慧者在城内设置了 N 个摄像头（由于他们的智商很低，只会用摄像头这种垃圾玩意），企图监视城内的人们。卡常、Trajan 决定找到这些摄像头并摧毁它们。

智慧之城里有一个用扩展卡常数原理设计的发射器，将其放在合适位置并设置半径以后，所有位于球心为这个发射器的位置、半径为指定值的球面上的目 标都能被发现。在卡常、Trajan 的带领下，智慧之城的人们用这个发射器进行了若干次实验，并发现了一些摄像头的位置。比较囧的是，每次发射都能且仅能发现一个摄像头，但是，反馈回来的结 果貌似有些不对劲……

后来人们终于找到了这 N 个摄像头的位置，并发现在他们用发射器进行实验的过程中，某些摄像头被移位——这就是导致反馈结果不对劲的原因。但是，在对实验结果进行分析的时候，人们 却肿么也回忆不起每次实验发现的摄像头是哪个了（可能是遭遇了灵异事件导致脑抽），只知道每次实验时发射器的位置和半径。你的任务就是，根据实验数据（为 了防止被反人类智慧者窃取，已经进行了加密）找出每次实验时被发射器找到的摄像头的编号。

Input

第一行两个正整数 N、M，表示摄像头数量（摄像头以 1 到 N 编号）和事件数量。

第二行两个实数 a、b，表示加密参数。

接下来 N 行，每行三个实数 (x,y,z)，表示 1 到 N 号摄像头的初始位置坐标。

接下来 M 行，每行描述一个事件，有两种可能的事件（保证其中实数的精度充分高）：

0 i x y z，表示将编号为 i 的摄像头的坐标改为 (x,y,z)；

1 x y z r，表示进行一次实验，将发射器放在 (x,y,z) 处并设置半径为r，数据保证每次实验能且仅能发现一个摄像头；

加密方式：设函数 f(x)=ax−bsinx，对于所有事件中的参数（i、x、y、z、r），均加密成 f(last_res×原值+1)，其中 last_res 为上一个实验事件的返回值（即发现的摄像头编号），若之前未进行过实验则 last_res=0.1。

Output

对于每个实验事件，输出发现的摄像头编号，一个一行。

 

Sample Input

6 10
1 0
-3.6 7.2 3.6
9.7 0.4 0.5
8.8 -4.7 0.5
9.6 8.2 -5.7
0.3 -9.9 1.5
0.5 -5.7 -1.0
0 1.3 1.92 0.13 1.85
1 1.98 1.55 1.2 2.360183811
1 8.2 0.9 2.1 9.981091248
1 -7.4 -44.0 11.2 83.061927835
1 20.8 -9.6 -11.8 31.598039153
0 10.0 11.2 -19.73 -19.1
0 13.0 7.3 28.6 22.6
0 4.0 22.3 -17.6 1.3
1 -3.2 -14.0 16.6 30.9549661993
0 7.0 -3.1 5.8 -0.9

Sample Output

1
6
2
3
1

HINT

 

比赛时打的是20分的暴力，结果得了40。。。

CODE:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define REP(i, s, n) for(int i = s; i <= n; i ++)
#define REP_(i, s, n) for(int i = n; i >= s; i --)
#define MAX_N 65536 + 10

using namespace std;

int n, m;
double a, b;
struct node{
    double X, Y, Z;
}P[MAX_N];
double last_res = 0.1;

double F(double x) {
    double l = -1e9, r = 1e9;
    while (l + 1e-9 < r) {
        double mid = (l + r) / 2;
        if (a * mid - b * sin(mid) < x) l = mid; 
        else r = mid;
    }
    return (l - 1) / last_res;
}

double dis(double x1, double y1, double z1, double x2, double y2, double z2){
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2);
}

int main(){
    scanf("%d%d%lf%lf", &n, &m, &a, &b);
    REP(i, 1, n){
        cin >> P[i].X >> P[i].Y >> P[i].Z;
    }
    last_res = 0.1;
    int c; double x, y, z, r;
    while(m --){
        scanf("%d", &c);
        if(c == 0){
            scanf("%lf%lf%lf%lf", &r, &x, &y, &z);
            r = F(r); x = F(x); y = F(y); z = F(z);
            int i = (int)(r + 0.5); 
            P[i].X = x; P[i].Y = y; P[i].Z = z;
        }
        else if(c == 1){
            scanf("%lf%lf%lf%lf", &x, &y, &z, &r);
            r = F(r); x = F(x); y = F(y); z = F(z);
            REP_(i, 1, n){
                if (abs(r * r - dis(x, y, z, P[i].X, P[i].Y, P[i].Z)) < 1e-5){
                    printf("%d\n", i);
                    last_res = i; break;
                }
            }
        }
    }
    return 0;
}

 

T3-----------------------------------------------------------------------------------------------------------------------------------------------

矩阵变换

Description

给出一个 N 行 M 列的矩阵A, 保证满足以下性质:

M>N。

矩阵中每个数都是 [0,N] 中的自然数。

每行中, [1,N] 中每个自然数都恰好出现一次。这意味着每行中 0 恰好出现 M−N 次。

每列中，[1,N] 中每个自然数至多出现一次。

现在我们要在每行中选取一个非零数，并把这个数之后的数赋值为这个数。我们希望保持上面的性质4，即每列中，[1,N] 中每个自然数仍然至多出现一次。

Input

第一行一个正整数 T，表示数据组数。

后面包含 T 组数据，各组数据之间无空行。每组数据以两个正整数 N,M 开始，接下来 N 行，每行 M 个用空格隔开的整数，意义如题所述。

Output

对于每组数据输出一行。如果有解，则输出 N 个整数，依次表示每一行取的数是多少。（这应该是一个 1 到 N 的排列）如果无解，则输出任意卖萌表情。

Sample Input

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

Sample Output

4 5 3 1 2
5 4 3 1 2

explanation 两组输入数据是相同的。由于结果不唯一，你可以给出任意一组合法答案

HINT

 

稳定婚姻（其实就是贪心）

CODE:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define REP(i, s, n) for(int i = s; i <= n; i ++)
#define REP_(i, s, n) for(int i = n; i >= s; i --)
#define MAX_N 200 + 10
#define MAX_M 400 + 10

using namespace std;

int n, m, B[MAX_N][MAX_M], G[MAX_N][MAX_N], N[MAX_N];
int M[MAX_N], num[MAX_N];
queue<int> q;

int main(){
    int T; scanf("%d", &T);
    while(T --){
        scanf("%d%d", &n, &m);
        REP(i, 1, n) REP(j, 1, m){
            scanf("%d", &B[i][j]);
            G[i][B[i][j]] = j;
        }
        REP(i, 1, n) q.push(i);
        REP(i, 1, n) num[i] = 1;
        memset(N, 0, sizeof(N));
        while(!q.empty()){
            int p = q.front(); q.pop();
            for(;;num[p] ++){
                if(B[p][num[p]]){
                    int p1 = B[p][num[p]], p2 = N[p1];
                    if(p2 == 0 || G[p2][p1] < G[p][p1]){
                        N[p1] = p; if(p2) q.push(p2); num[p] ++; break;
                    }
                }
            }
        } 
        REP(i, 1, n) M[N[i]] = i;
        REP(i, 1, n) printf("%d ", M[i]); printf("\n");
    }
    return 0;
}

转载于:https://www.cnblogs.com/ALXPCUN/p/4569483.html