ACM-HDOJ 2006 Asia Regional Shanghai

A-Acm Team Section

题意：

选拔参加ACM现场赛队伍的方式有三种：a、过题数至少是m道。b、在WF中排名前20。c、举办过当年的省赛。满足任意一个条件，该学校就可以获得一个名额，最多三个。

分析：

题意比较简单，但是有一点容易弄错的就是，三个条件中的每一个，每一个学校只能满足一次，也就是说即使某一个学校有两支队伍满足a条件，获得的名额也只算一个。

源代码：

#include <cstdio>
#include <cstring>

int data[105];

int main()
{//freopen("sample.txt", "r", stdin);
    int s, t, m, cas=0;
    while(~scanf("%d%d%d",&s,&t,&m) && (s+t+m))
    {
        int sum = 0;
        memset(data, 0, sizeof(data));
        for(int i=1; i<=s; ++i)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            sum += b + c;                 // 判断b、c条件
        }
        for(int i=1; i<=t; ++i)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            if(!data[a] && b>=m)          // 判断a条件
                ++sum, ++data[a];
        }
        printf("Case %d: %d\n", ++cas, sum);
    }
}

B-Balancing the Scale

题意：

给出16个数字，求满足条件的排列方式有多少种，旋转、翻转相同的算作一种。

分析：

源代码：

C-Contestants

题意：

给出一张无向图，每个节点给定一个数，求将该图分成两个图后，它们各自节点上的数字之和的差的最小值是多少。

分析：

首先将图用邻接表保存下来，然后算出每个节点及其子节点上的数字之和并保存，最后遍历每个节点，更新最小值即可。

源代码：

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

#define LL __int64
const int MAXN = 100005;
LL sum[MAXN], vis[MAXN];
vector<int> edge[MAXN];

void dfs(int u)  // 递归遍历图，计算后缀和
{
    vis[u] = 1;
    for(int i=0; i<edge[u].size(); ++i)
    {
        int v = edge[u][i];
        if(!vis[v])
        {
            dfs(v);
            sum[u] += sum[v];
        }
    }
}

int main()
{//freopen("sample.txt", "r", stdin);
    int n, m, t=0;
    while(~scanf("%d%d", &n,&m) && (n+m))
    {
        LL total = 0;
        for(int i=1; i<=n; ++i)
        {
            vis[i] = 0;
            edge[i].clear();
            scanf("%I64d", &sum[i]);
            total += sum[i];
        }
        for(int i=1; i<=m; ++i)  // 用邻接表保存无向图
        {
            int a, b;
            scanf("%d%d", &a, &b);
            edge[a].push_back(b);
            edge[b].push_back(a);
        }
        dfs(1);
        LL ans = total;
        for(int i=1; i<=n; ++i)  // 更新答案，计算公式为（total-sum[i]）-sum[i]
            ans = min(ans, abs(total-2*sum[i]));
        printf("Case %d: %I64d\n", ++t, ans);
    }
    return 0;
}

D-Distant Galaxy

题意：

给出一些点的坐标，求最大的点数，使得这些点都在一个矩形的边上。

分析：

点击打开链接

源代码：

E-Escape Plan

题意：

分析：

源代码：

F-False Perceptions

题意：

分析：

源代码：

G-Guarding Zion

题意：

分析：

源代码：

H-Harmony Forever

题意：

对于集合S，有两种操作：1、B X；2、A Y。B X代表将X加入集合S，并赋予X一个序号，代表它是第几个数；A Y代表从集合S中找出mod Y最小的数，输出的是该数的序号。

分析：

首先考虑暴力，复杂度也只有o(n)，就是直接将集合中的的所有数取模，然后取最小的就可以了，这样写下来发现同样的题目在不同的oj上会出现不同的结果，可能会超时。那如何优化呢？显然只能优化查询的时间，如果可以将复杂度由o(n)降到o(logn)就万事大吉了。联想到线段树的查询时间正是o(logn)的，所以考虑一下这道题能否使用线段树求解（ 点击打开链接）。首先，题目要求的是集合s中mod y的最小值的那个数据，但是我们又不能直接维护最小值，因为y是动态的，然后换个角度，考虑到x和y的范围是固定的，如果我们以它作为依据建立线段树，那么就可以查询范围最小值，即mod y的最小值，因为被除数越小余数也就越小，当然这是有条件的，那就是被除数应满足区间[m*y,(m+1)*y-1]，m=1,2,3...，并且在这个区间里，根据抽屉原理（ 点击打开链接），不可能出现两个相同的余数。这样一来，就成了分区间查询，每个区间的复杂度都是log(y)，总复杂度就是(s/y)*log(y)，显然当y越大，相对于o(n)来说越优化，而当y较小时反而增加了log级别的复杂度。

源代码：

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>

using namespace std;
#define N 500000
#define INF 100000000
vector<int> vct;

struct Nod
{
    int l, r;
    int mins;
}node[(N<<2)+10];

int maxInput;
int posArray[N+10];

void building(int l,int r,int p)
{
    node[p].l = l;
    node[p].r = r;
    node[p].mins = INF;
    if(l == r) return ;
    int mid = (l+r)>>1;
    building(l, mid, p<<1);
    building(mid+1, r, p<<1|1);
}

void update(int x, int p)
{
    if(node[p].l>x || node[p].r<x) return;
    if(node[p].l==node[p].r && node[p].l==x)
    {
        node[p].mins = x;
        return;
    }
    update(x, p<<1);
    update(x, p<<1|1);
    node[p].mins = min(node[p<<1].mins, node[p<<1|1].mins);
}

int query(int l, int r, int index)  //找[l,r]区间的最小值
{
    if(node[index].l>r || node[index].r<l) return INF;
    if(node[index].l>=l && node[index].r<=r) return node[index].mins;
    if(node[index].l < node[index].r)
        return min(query(l,r,index<<1), query(l,r,index<<1|1));
    return INF;
}

int searchs(int y)  // 直接暴力判断
{
    int minAns=INF, id=0;
    for(int i=vct.size()-1; i>=0; i--)
    {
        if(vct[i]%y == 0) return i+1;
        if(vct[i]%y < minAns)
        {
            minAns = vct[i]%y;
            id = i+1;
        }
    }
    return id;
}

int solve(int y)
{
    int l=0, r=y-1, minAns=INF, id, temp;
    while(l <= maxInput)  // 利用鸽巢原理循环分区间查询
    {
        if(maxInput < r)  r = N;
        temp = query(l, r, 1);
        if(temp != INF)
        {
            if(temp%y < minAns)
            {
                minAns = temp%y;
                id = posArray[temp];
            }
            else if(temp%y==minAns && posArray[temp]>id)
            {
                id = posArray[temp];
            }
        }
        l += y;
        r += y;
    }
    return id;
}

int main()
{//freopen("sample.txt", "r", stdin);
    int t, cas=1;
    while(~scanf("%d",&t) && t)
    {
        building(0, N, 1);  // 以范围建树
        char op[5];
        maxInput = 0;
        vct.clear();
        if(cas != 1) printf("\n");
        printf("Case %d:\n", cas++);
        while(t--)
        {
            scanf("%s", op);
            if(op[0] == 'B')
            {
                int x;
                scanf("%d", &x);
                if(maxInput < x)  maxInput = x;
                vct.push_back(x);
                posArray[x] = vct.size();
                update(x, 1);  // 更新维护的最小值信息
            }
            else if(op[0] == 'A')
            {
                int y;
                scanf("%d", &y);
                if(vct.size() == 0) puts("-1");
                else if(y <= 5000)  printf("%d\n", searchs(y));  // 当y较小时直接判断会更快
                else printf("%d\n", solve(y));  // 查询信息
            }
        }
    }
    return 0;
}

I-Interesting Yang Yui Triangle

题意：

求杨辉三角的第n+1行中不能被素数p整除的数的个数。

分析：

点击打开链接，然后可以算n的p进制的每一位ai，答案就是(a1+1)*(a2+1)*...*(ak+1)。

源代码：

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

#define LL __int64
const int MAXN = 1e9;

int main()
{//freopen("sample.txt", "r", stdin);
    int p, n, t=0;
    while(~scanf("%d%d",&p,&n) && (p+n))
    {
        int sum = 1;
        for(int i=n; i>0; i/=p)  // 枚举每一位
            sum *= i%p + 1;
        printf("Case %d: %04d\n", ++t, sum%10000);
    }
    return 0;
}

J-John's Canonical Difference Bound Matrices

题意：

分析：

源代码：