NOIP2013提高组Day1 解题报告

(同步个人博客 http://sxysxy.org/blogs/37 到csdn)

总的来说

NOIP2013Day1的这三道题，感觉总的来说还是并不难，并且也比较符合套路。T1是良心的一眼送分题，T2是比较需要思考，代码写起来比较简单的但建立模型需要好好思考的偏重算法思维的题目，T3是比较注重代码能力，代码量稍大(还是只是因为我人傻写得多?)的题目。

T1转圈游戏

http://cojs.tk/cogs/problem/problem.php?pid=1437

在演草纸上模拟模拟，稍有常识的人就能看出这个求一下10^k后瞎搞搞就出来了。关键也就只是求下10^k，快速幂即可。 注意使用long long。

代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
long long n;

long long fast_pow(long root, long time)
{
    long ans = 1;
    while(time)
    {
        if(time & 1)
            ans = (root*ans)%n;
            root = (root*root)%n;
            time >>= 1;
    }
    return ans%n;
}
int main()
{
    //freopen("CircleNOIP2013.in", "r", stdin);
    //freopen("CircleNOIP2013.out", "w", stdout);
    long long m,k,x;
    long long t,r;
    cin >> n >> m >> k >> x;
    r = 0;
    t = fast_pow(10LL, k);
    t *= m;
    t %= n;
    r = (x+t)%n;
    cout << r << endl;
    return 0;
}

T2火柴排队

http://cojs.tk/cogs/problem/problem.php?pid=1438

这个题就比较妙了，在cogs上难度系数甚至比当天的t3还高(当然cogs是标的难度系数我早已经不太相信了= =)。

这个题目要求最小化 ∑ (ai-bi)^2 (下标i=1,2..n)。展开这个式子得sum = ∑ ai^2 + bi^2 - 2ai×bi。其中∑ ai^2 + bi^2对于一组数据来说是一个定值，可看做常数，那么现在要使得sum最小，就应使得 ∑ ai×bi 最大。这里有个结论便是当a1<=a2…<=an且b1<=b2…<=bn时，∑ ai×bi值最大。我们可以这样证明:对于任意的 a1 < a2∈序列a, b1 < b2∈序列b，若a1×b2+a2×b1 > a1×b1+a2×b2 则移项提公因式得a1(b2-b1) > a2(b2-b1)，消去得a1 > a2与条件a1 < a2相悖。　因此在满足a1<=a2…<=an且b1<=b2…<=bn时，对于任意的 a1 < a2∈序列a, b1 < b2∈序列b有a1×b1+a2×b2 >= a1×b2+a2×b1。这就是告诉我们，每每两个序列里面名次相同的数配在一起，得到的∑ ai×bi值是最大的，这样正是我们需要做的。

题目允许在两列火柴上进行交换，但是显然移动两列火柴与只移动其中一列火柴是等价的(对两个名次相同的数移动到同一位置的影响是等价的)。因此这里可以固定序列A，只移动序列B。将B中元素在A中的位置找到构成一个序列C，对于这个序列C发现显然有 对于任意的相邻的i < j=i+1 ∈ [1,n]，若Ci>Cj那么Ci与Cj需要发生一次交换。题目的答案即是交换的次数。交换的次数显然就是序列C中逆序对(i

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <list>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
#define MAXN 100003
#define MOD 99999997
int A[MAXN], B[MAXN];
int rkB[MAXN];
int ord[MAXN];
inline bool rankb(int a, int b)
{
    return B[a] < B[b];  
}
int ans = 0;
int tmp[MAXN];
void msort(int l, int m, int r)
{
    int i = l;
    int j = m+1;
    int k = l;
    while(i <= m && j <= r)
    {
        if(ord[i] > ord[j])
        {
            tmp[k++] = ord[j++];
            ans = (ans+m-i+1)%MOD;
        }else
        {
            tmp[k++] = ord[i++];
        }
    }
    while(i <= m)tmp[k++] = ord[i++];
    while(j <= r)tmp[k++] = ord[j++];
    for(int p = l; p <= r; p++)
        ord[p] = tmp[p];
}
void gg(int l, int r)
{
    if(l < r)
    {
        int m = (l+r)>>1;
        gg(l, m);
        gg(m+1, r);
        msort(l, m, r);
    }
}
int main()
{
    //freopen("MatchNOIP2013.in", "r", stdin);
    //freopen("MatchNOIP2013.out", "w", stdout);
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", A+i);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", B+i);
        rkB[i] = i;       //初始化B的名次
    }
    sort(rkB+1, rkB+1+n, rankb);   //排序后满足 B[rkB[i]] = B中第i小的数
                                //rkB[i] 即为B中第i小的数在B中的位置
    for(int i = 1; i <= n; i++)
        ord[i] = rkB[A[i]];        //rkB[A[i]]就是第A[i]小的数的位置
    //这样我们在线性的时间内快速找到了B中元素在A中对应的位置，保存在ord数组中
    gg(1, n);    //求个逆序对
    printf("%d\n", ans);
    return 0;
}

T3货车运输

http://cojs.tk/cogs/problem/problem.php?pid=1439

也就是是每个司机都希望自己的路径上的限重尽可能大，在这种情况下询问自己路径上限重的最小值。这个题目就比t2容易想多了，就连我这样的蒟蒻也一眼(好吧其实还是我太蒟蒻了，第一样看觉得像是网络流= =)看出来这，对于司机们这样的要求可以构造最大生成树，然后求最大生成树上两点之间限重最小值解决。

于是用kruskal算法构造最大生成树，树链剖分+线段树维护树链上的最小值。代码洋洋洒洒写了200+行还1A了。注意这个原图上所有点不一定都在同一个联通块上，不过前面用kruskal的时候就已经顺便并查集维护了一下联通性，这多妙啊! 代码如下:

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <cctype>
using namespace std;
#define MAXN 10003
#define MAXM 50003
inline int fast_read()
{
    int r;
    char c;
    while(c = getchar())
    {
        if(c >= '0' && c <= '9')
        {
            r = c^0x30;
            break;
        }
    }
    while(isdigit(c = getchar()))
        r = (r<<3)+(r<<1)+(c^0x30);
    return r;
}

struct edge
{
    int from, to;
    int value;
    void scan()
    {
        from = fast_read();
        to = fast_read();
        value = fast_read();
    }
    bool operator<(const edge &o) const
    {
        return value > o.value;
    }
}edges[MAXM];
vector<int> G[MAXN];
int n, m;
int uset[MAXN];
bool intree[MAXM];
int finds(int x)
{
    return x == uset[x]? x:uset[x] = finds(uset[x]);
}
void make_maxtree()
{
    sort(edges+1, edges+1+m);
    for(int i = 1; i <= n; i++)uset[i] = i;
    for(int i = 1; i <= m; i++)
    {
        edge &e = edges[i];
        int x = finds(e.from);
        int y = finds(e.to);
        if(x != y)
        {
            intree[i] = true;
            uset[x] = y;
        }
    }
}
int size[MAXN], top[MAXN], parent[MAXN], deep[MAXN], son[MAXN];
void dfs(int u, int f, int d)
{
    parent[u] = f;
    deep[u] = d;
    size[u] = 1;
    for(int i = 0; i < G[u].size(); i++)
    {
        int to = G[u][i];
        if(to != f)
        {
            dfs(to, u, d+1);
            size[u] += size[to];
            if(size[to] > size[son[u]])
                son[u] = to;
        }
    }
}
int has[MAXN];
int hasid = 0;
void dfs(int u, int tp)
{
    has[u] = ++hasid;
    top[u] = tp;
    if(!son[u])return;
    dfs(son[u], tp);
    for(int i = 0; i < G[u].size(); i++)
    {
        int to = G[u][i];
        if(to != parent[u] && to != son[u])
            dfs(to, to);
    }
}
int val[MAXN];
struct node
{
    int l, r, ls, rs, minv;
}ns[MAXN<<1];
int root = 1;
int last = root;
void pushup(node &d)
{
    d.minv = min(ns[d.ls].minv, ns[d.rs].minv);
}
int build(int l, int r)
{
    if(l > r)return 0;
    int cur = last++;
    node &d = ns[cur];
    d.l = l;
    d.r = r;
    if(l == r)
        d.minv = val[l];
    else
    {
        int m = (l+r)>>1;
        if(l <= m)
        {
            d.ls = build(l, m);
            d.rs = build(m+1, r);
            pushup(d);
        }
    }
    return cur;
}
int querytree(int c, int l, int r)
{
    if(!c)return 0x7fffffff;
    node &d = ns[c];
    if(d.l == l && d.r == r)
        return d.minv;
    else if(l >= ns[d.rs].l)
        return querytree(d.rs, l, r);
    else if(r <= ns[d.ls].r)
        return querytree(d.ls, l, r);
    else
        return min(querytree(d.ls, l, ns[d.ls].r), querytree(d.rs, ns[d.rs].l, r));
}
int query(int u, int v)
{
    int ans = 0x7fffffff;
    int t1 = top[u], t2 = top[v];
    while(t1 != t2)
    {
        if(deep[t1] < deep[t2])
        {
            swap(t1, t2);
            swap(u, v);
        }
        ans = min(ans, querytree(1, has[t1], has[u]));
        u = parent[t1];
        t1 = top[u];
    }
    if(u == v)return ans;
    else
    {
        if(deep[u] > deep[v])
            swap(u, v);
        return min(ans, querytree(1, has[son[u]], has[v]));
    }
}
int main()
{
   // freopen("truck.in", "r", stdin);
   // freopen("truck.out", "w", stdout);
    n = fast_read();
    m = fast_read();
    for(int i = 1; i <= m; i++)
        edges[i].scan();
    make_maxtree();
    for(int i = 1; i <= m; i++)
    {
        if(intree[i])
        {
            edge &e = edges[i];
            G[e.from].push_back(e.to);
            G[e.to].push_back(e.from);
        }
    }
    for(int i = 1; i <= n; i++)
        if(!size[i])  //没有去过这个点
        {
            dfs(i, 0, 1);
            dfs(i, i);
        }
    for(int i = 1; i <= m; i++)
    {
        if(intree[i])
        {
            edge &e = edges[i];
            if(deep[e.to] < deep[e.from])
                swap(e.from, e.to);
            val[has[e.to]] = e.value;
        }
    }
    build(1, hasid);
    int q;
    q = fast_read();
    while(q--)
    {
        int x, y;
        x = fast_read();
        y = fast_read();
        if(finds(x) != finds(y))
            puts("-1");
        else
            printf("%d\n", query(x, y));
    }
    return 0;
}

/*
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
*/