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

题意：
分析：
源代码：