noip 2013 day1

转圈游戏

题目描述

n 个小伙伴（编号从 0 到 n-1）围坐一圈玩游戏。按照顺时针方向给 n 个位置编号，从0 到 n-1。最初，第 0 号小伙伴在第 0 号位置，第 1 号小伙伴在第 1 号位置，……，依此类推。游戏规则如下：每一轮第 0 号位置上的小伙伴顺时针走到第 m 号位置，第 1 号位置小伙伴走到第 m+1 号位置，……，依此类推，第n − m号位置上的小伙伴走到第 0 号位置，第n-m+1 号位置上的小伙伴走到第 1 号位置，……，第 n-1 号位置上的小伙伴顺时针走到第m-1 号位置。

现在，一共进行了 10^k轮，请问 x 号小伙伴最后走到了第几号位置。

输入输出格式

输入格式：

输入文件名为 circle.in。

输入共 1 行，包含 4 个整数 n、m、k、x，每两个整数之间用一个空格隔开。

输出格式：

输出文件名为 circle.out。

输出共 1 行，包含 1 个整数，表示 10

k 轮后 x 号小伙伴所在的位置编号。

输入输出样例

输入样例#1： 

10 3 4 5

输出样例#1： 

5

说明

对于 30%的数据，0 < k < 7；

对于 80%的数据，0 < k < 10^7；

对于 100%的数据，1 <n < 1,000,000，0 < m < n，1 ≤ x ≤ n，0 < k < 10^9

。

题解：(x + m*10^k) % n, 快速幂

#include <bits/stdc++.h>

using namespace std;
int n, m, k, x;
#define ll long long
ll mul(ll a, ll b){
    ll ret = 1;
    for(;b;b>>=1,a=a*a%n)
        if(b & 1)ret = ret * a % n;
    return ret;
}
int main()
{
    cin>>n>>m>>k>>x;
    ll a = mul(10, k);
    ll ans = (x%n + m*a%n) % n;
    cout<<ans;
    return 0;
}

火柴排队

题目描述

涵涵有两盒火柴，每盒装有 n 根火柴，每根火柴都有一个高度。 现在将每盒中的火柴各自排成一列， 同一列火柴的高度互不相同， 两列火柴之间的距离定义为： ∑(ai-bi)^2

其中 ai 表示第一列火柴中第 i 个火柴的高度，bi 表示第二列火柴中第 i 个火柴的高度。

每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请问得到这个最小的距离，最少需要交换多少次？如果这个数字太大，请输出这个最小交换次数对 99,999,997 取模的结果。

输入输出格式

输入格式：

输入文件为 match.in。

共三行，第一行包含一个整数 n，表示每盒中火柴的数目。

第二行有 n 个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。

第三行有 n 个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。

输出格式：

输出文件为 match.out。

输出共一行，包含一个整数，表示最少交换次数对 99,999,997 取模的结果。

输入输出样例

输入样例#1： 

4
2 3 1 4
3 2 1 4

输出样例#1： 

1

输入样例#2： 

4
1 3 4 2
1 7 2 4

输出样例#2： 

2

说明

【输入输出样例说明1】

最小距离是 0，最少需要交换 1 次，比如：交换第 1 列的前 2 根火柴或者交换第 2 列的前 2 根火柴。

【输入输出样例说明2】

最小距离是 10，最少需要交换 2 次，比如：交换第 1 列的中间 2 根火柴的位置，再交换第 2 列中后 2 根火柴的位置。

【数据范围】

对于 10%的数据， 1 ≤ n ≤ 10；

对于 30%的数据，1 ≤ n ≤ 100；

对于 60%的数据，1 ≤ n ≤ 1,000；

对于 100%的数据，1 ≤ n ≤ 100,000，0 ≤火柴高度≤ maxlongint

题解：求逆序对

1。并归排序

#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define maxn 100008
#define M 99999997
void read(ll &x){
    ll f=1;x=0;char s=getchar();
    while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
    while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
struct Point{int id;ll val;}a[maxn],b[maxn];
bool cmp(Point a, Point b){return a.val < b.val;}
ll ans,q[maxn],rt[maxn];
void msort(int lf, int rg){
    if(lf == rg)return ;
    int m = (lf + rg) >> 1;
    msort(lf, m);msort(m+1, rg);
    int i = lf, j = m + 1, pos = lf;    
    while(i <= m && j <= rg){
        if(q[i] <= q[j])rt[pos++] = q[i++];
        else {
            rt[pos++] = q[j++];
            ans = (ans + m - i + 1) % M;
        }
    }
    while(i <= m)rt[pos++] = q[i++];
    while(j <= rg)rt[pos++] = q[j++];
    for(int it = lf; it <= rg; it++)q[it] = rt[it];
}

int main()
{
    //freopen("match.in","r",stdin);
    //freopen("match.out","w",stdout);
    int n;
    scanf("%d",&n);
    for(int i = 1; i <= n; i++)
        read(a[i].val), a[i].id = i;
    for(int i = 1; i <= n; i++)
        read(b[i].val), b[i].id = i; 
    sort(a+1, a+1+n, cmp);
    sort(b+1, b+1+n, cmp);
    for(int i = 1; i <= n; i++)
        q[a[i].id] = b[i].id;
    msort(1, n);
    cout<<ans;
    return 0;
}

2。树状数组

#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define maxn 100008
#define M 99999997
void read(ll &x){
    ll f=1;x=0;char s=getchar();
    while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
    while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
struct Point{int id;ll val;}a[maxn],b[maxn];
bool cmp(Point a, Point b){return a.val < b.val;}
ll ans,q[maxn],c[maxn];
int n;
void add(int x, int del){
    while(x <= n){
        c[x] += del;
        x += x & -x;
    }
}
ll sum(int x){
    ll rt = 0;
    while(x > 0){
        rt = (rt + c[x]) % M;
        x -= x & -x;
    }
    return rt;
}
int main()
{
    //freopen("match.in","r",stdin);
    //freopen("match.out","w",stdout);
    scanf("%d",&n);
    for(int i = 1; i <= n; i++)
        read(a[i].val), a[i].id = i;
    for(int i = 1; i <= n; i++)
        read(b[i].val), b[i].id = i;
    sort(a+1, a+1+n, cmp);
    sort(b+1, b+1+n, cmp);
    for(int i = 1; i <= n; i++)
        q[a[i].id] = b[i].id;
    for(int i = 1; i <= n; i++){
        add(q[i], 1);
        ans = (ans + i - sum(q[i])) % M;
    }
    cout<<ans;
    return 0;
}

货车运输

题目描述

A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入输出格式

输入格式：

输入文件名为 truck.in。

输入文件第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道

路。 接下来 m 行每行 3 个整数 x、 y、 z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意： x 不等于 y，两座城市之间可能有多条道路 。

接下来一行有一个整数 q，表示有 q 辆货车需要运货。

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意： x 不等于 y 。

输出格式：

输出文件名为 truck.out。

输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货

车不能到达目的地，输出-1。

输入输出样例

输入样例#1： 

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

输出样例#1： 

3
-1
3

说明

对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q< 1,000；

对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q< 1,000；

对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q< 30,000，0 ≤ z ≤ 100,000。

题解：先求出最大生成树，新建图，此时就是一棵树的结构，倍增跑LCA树边记录路上最小限制

#include <bits/stdc++.h>

using namespace std;
const int maxn = 10005, maxm = 100000+20, inf = 1000000008;
int n,m,tot2,tot,P = 20,f[maxn];
int dep[maxn],dp[maxn][25],anc[maxn][25],hh[maxn],h[maxn];

struct Edge{int v,w,nxt;}g[maxm];
struct edge{int v,u,w;}G[maxm];
void nadd(int u, int v, int w){
    g[++tot2].v = v;g[tot2].w = w;g[tot2].nxt = hh[u];hh[u] = tot2;
}
bool cmp(edge a, edge b){
    return a.w > b.w;
}
int find(int x){
    return f[x] = (f[x] == x ? x : find(f[x]));
}
bool Same(int u, int v){
    return find(u) == find(v);
}
void Union(int u, int v){
    int x = find(u), y = find(v);
    f[x] = y;
}
void getmaxtree(){
    for(int i = 1; i <= n; i++)f[i] = i;
    sort(G+1, G+1+m, cmp);
    for(int i = 1; i <= m; i++){
        int u = G[i].u, v = G[i].v;
        if(!Same(u, v)){
            Union(u, v);
            nadd(v, u, G[i].w);
            nadd(u, v, G[i].w);
        }
    }
}
void dfs(int u, int fa){
    dep[u] = dep[fa] + 1;
    anc[u][0] = fa;
    for(int i = 1; i <= P; i++){
        anc[u][i] = anc[anc[u][i-1]][i-1];
        dp[u][i] = min(dp[u][i-1],dp[anc[u][i-1]][i-1]);
    }

    for(int i = hh[u]; i; i = g[i].nxt){
        int v = g[i].v;
        if(v == fa)continue;
        dp[v][0] = g[i].w;
        dfs(v, u);

    }
}
int lca(int u, int v){
    int ans = inf;
    if(dep[u] < dep[v])swap(u, v);
    int t = dep[u] - dep[v];
    for(int p = 0; t; t>>=1, p++)
        if(t & 1){
            ans = min(ans, dp[u][p]);
            u = anc[u][p];
        }
    if(u == v)return ans;
    for(int p = P; p >= 0; p--)
    if(anc[u][p] != anc[v][p]){
        ans = min(ans, min(dp[u][p], dp[v][p]));
        u = anc[u][p]; v = anc[v][p];
    }
    ans=min(ans,min(dp[u][0],dp[v][0]));
    return ans;
}
int main()
{
    //freopen("truck.in","r",stdin);
    //freopen("truck.out","w",stdout);
    int q;
    memset(dp, 127, sizeof(dp));
    scanf("%d%d",&n,&m);
    for(int i = 1; i <= m; i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        G[i].u = u; G[i].v = v; G[i].w = w;
    }
    getmaxtree();
    for(int i = 1; i <= n; i++)
        if(!dep[i])
            dfs(i, i);
    scanf("%d",&q);
    for(int i = 1; i <= q; i++){
        int s,t;
        scanf("%d%d",&s,&t);
        if(!Same(s,t))puts("-1");
        else printf("%d
",lca(s, t));
    }
    return 0;
}
/*
10 10
1 2 4
2 3 3
4 3 2
4 6 5
5 4 7
2 5 8
5 6 1
6 9 12
8 7 5
7 8 15
20 3 5
8 9
*/