目录
1005: Binary Search Tree analog
1034: The Composition of Letters
1068: Count the Number of Cycles
1299: Number Transformation II
1004: Xi and Bo
#include <stdio.h>
#define N 105
int fa[N];
int a[N];
void InitSet(int n){
for(int i=1; i<=n; i++) fa[i] = i ;
}
int Find(int x) {
return fa[x] == x ? x : fa[x] = Find(fa[x]) ;
}
bool Merge(int u ,int v) {
int fu = Find(u) , fv = Find(v) ;
if(fu != fv) fa[fv] = fu ;
return fu != fv ;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
InitSet(100);
int kstart,kend;
scanf("%d%d",&kstart,&kend);
int n;
scanf("%d",&n);
while(n--)
{
int m;
scanf("%d",&m);
for(int i=0;i<m;i++)
scanf("%d",&a[i]);
for(int i=1;i<m;i++)
Merge(a[i-1],a[i]);
}
printf("%s\n",Find(kstart)==Find(kend)?"Yes":"No");
}
return 0;
} 1005: Binary Search Tree analog
#include <iostream>
using namespace std;
int a[1001];
// BST的结点
typedef struct node
{
int key;
struct node *lChild, *rChild;
} Node, *BST;
// 在给定的BST中插入结点，其数据域为element, 使之称为新的BST
bool BSTInsert(Node * &p, int element)
{
if(NULL == p) // 空树
{
p = new Node;
p->key = element;
p->lChild = p->rChild = NULL;
return true;
}
if(element < p->key) // 递归
return BSTInsert(p->lChild, element);
return BSTInsert(p->rChild, element); // 递归
}
// 建立BST
void createBST(Node * &T, int a[], int n)
{
T = NULL;
int i;
for(i = 0; i < n; i++)
{
BSTInsert(T, a[i]);
}
}
// 先序遍历
int pre[1001];
int mid[1001];
int fs[1001];
int coun=0;
void preOrderTraverse(BST T)
{
if(T)
{
pre[coun++]=T->key;
preOrderTraverse(T->lChild);
preOrderTraverse(T->rChild);
}
}
// 中序遍历
void inOrderTraverse(BST T)
{
if(T)
{
inOrderTraverse(T->lChild);
mid[coun++] =T->key;
inOrderTraverse(T->rChild);
}
}
void f(BST T)
{
if(T)
{
f(T->lChild);
f(T->rChild);
fs[coun++]=T->key;
}
}
int main()
{
int Ts;
cin>>Ts;
while(Ts--)
{
int n;
BST T;
cin>>n;
for(int i=0; i<n; i++)
cin>>a[i];
// 并非所有的a[]都能构造出BST,所以，最好对createBST的返回值进行判断
createBST(T, a, n);
coun=0;
preOrderTraverse(T);
for(int i=0; i<coun-1; i++)
cout<<pre[i]<<" ";
cout<<pre[coun-1];
cout << endl;
coun=0;
inOrderTraverse(T);
for(int i=0; i<coun-1; i++)
cout<<mid[i]<<" ";
cout<<mid[coun-1];
cout << endl;
coun=0;
f(T);
for(int i=0; i<coun-1; i++)
cout<<fs[i]<<" ";
cout<<fs[coun-1];
cout << endl<<endl;;
}
return 0;
}1014: 西湖三人行
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#define LL long long
#define inf 1000000000
#define Pi acos(-1.0)
#define free(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
using namespace std;
const int maxn=200,maxm=1010,maxw=3010;
struct edge {int to,next,w;}e[maxm<<1];
struct data {int num,w;};
int head[maxn],vis[maxn][maxw],t[maxn][maxn],n,m,S,T,B,L,cnt;
int dis[maxn][maxw],f[maxn][maxn],d[maxn][maxn];
vector<int> v[maxn];
queue<data> q;
void link(int u,int v,int w) {
e[++cnt].to=v;e[cnt].next=head[u];head[u]=cnt;e[cnt].w=w;
e[++cnt].to=u;e[cnt].next=head[v];head[v]=cnt;e[cnt].w=w;
}
void Init() {
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++) f[i][j]=d[i][j]=inf;
for (int i=1;i<=n;i++) f[i][i]=head[i]=0;
for (int i=1;i<=n;i++) v[i].clear();
while (!q.empty()) q.pop();
cnt=0;
}
void Floyed() {
for (int k=1;k<=n;k++)
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (i!=j && j!=k && i!=k)
f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
}
void walk(data x) {
for (int i=head[x.num];i;i=e[i].next)
if (dis[e[i].to][x.w+e[i].w*3]>dis[x.num][x.w]+e[i].w*1000) {
dis[e[i].to][x.w+e[i].w*3]=dis[x.num][x.w]+e[i].w*1000;
if (!vis[e[i].to][x.w+e[i].w*3]) {
q.push((data){e[i].to,x.w+e[i].w*3});
vis[e[i].to][x.w+e[i].w*3]=1;
}
}
}
void bus(data x) {
for (int i=0;i<(int)v[x.num].size();i++) {
int s,p=v[x.num][i];
for (s=1;s<=t[p][0];s++) if (t[p][s]==x.num) break;
s++;
double D=0;
for (s;s<=t[p][0];s++) {
D+=d[t[p][s-1]][t[p][s]];
if (dis[t[p][s]][x.w+6]>dis[x.num][x.w]+D*250) {
dis[t[p][s]][x.w+6]=dis[x.num][x.w]+D*250;
if (!vis[t[p][s]][x.w+6]) {
q.push((data){t[p][s],x.w+6});
vis[t[p][s]][x.w+6]=1;
}
}
}
}
}
void taxi(data x) {
for (int i=1;i<=n;i++) if (i!=x.num) {
int W=x.w+10+(f[x.num][i]>3 ? 2*(f[x.num][i]-3) : 0);
if (dis[i][W]>dis[x.num][x.w]+f[x.num][i]*125) {
dis[i][W]=dis[x.num][x.w]+f[x.num][i]*125;
if (!vis[i][W]) {
q.push((data){i,W});
vis[i][W]=1;
}
}
}
}
void SPFA(int s) {
for (int i=1;i<=n;i++)
for (int j=0;j<=L;j++) dis[i][j]=inf;
dis[s][0]=0;
q.push((data){s,0});
while (!q.empty()) {
data x=q.front();q.pop();
vis[x.num][x.w]=0;
walk(x);
bus(x);
taxi(x);
}
}
int main() {
int Case;scanf("%d",&Case);
while (Case--) {
scanf("%d%d%d%d%d%d",&L,&n,&m,&S,&T,&B);
Init();
for (int uu,vv,ww,i=1;i<=m;i++) {
scanf("%d%d%d",&uu,&vv,&ww);
link(uu,vv,ww);
d[uu][vv]=d[vv][uu]=f[uu][vv]=f[vv][uu]=ww;
}
for (int i=1;i<=B;i++) {
scanf("%d",&t[i][0]);
for (int j=1;j<=t[i][0];j++) {
scanf("%d",&t[i][j]);
v[t[i][j]].push_back(i);
}
}
Floyed();
SPFA(S);
int ans=inf;
for (int i=0;i<=L;i++) ans=min(ans,dis[T][i]);
if (ans==inf) printf("no\n");
else printf("%d\n",ans);
}
return 0;
}1020: 真三国无双
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<queue>
#include<stack>
#include<math.h>
#include<string.h>
#include<stdlib.h>
using namespace std;
typedef long long ll;
int main(){
// freopen("input.txt","r",stdin);
int t;
scanf("%d",&t);
while(t--){
double a,b,d;
scanf("%lf%lf%lf",&a,&b,&d);
double x=(a+b-d)/10,y=a/10;
if(x>=0&&x<360&&x<=y&&x<=a)
printf("%.2lf\n",x);
else if(x<0)
printf("0.00\n");
else
printf("IMPOSSIBLE\n");
}
return 0;
} 1023: 修路
#include <iostream>
#include <stdio.h>
using namespace std;
const int M=305;
const int MT=300*1000+5;
int p[M];
int isc(int m,int n,int t) //该时间下能否完成修路任务
{
int co=1;
int su=0;
for(int i=1;i<=m;i++)
{
if(p[i]>t) //每段路必须不长于时间
return 0;
if(su+p[i]<=t)
su+=p[i];
else
{
su=p[i];
co++;
}
}
return co<=n;
}
int bs(int m,int n)
{
int lo=0,hi=MT;
int mid,ans=MT;
while(lo<=hi)
{
mid=(lo+hi)/2;
if(isc(m,n,mid))
{
ans=min(ans,mid);
hi=mid-1;
}
else
lo=mid+1;
}
return ans;
}
int main()
{
int t,n,m;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
scanf("%d",&p[i]);
printf("%d\n",bs(m,n));
}
return 0;
} 1024: Mining
#include <stdio.h>
#include <memory.h>
#define N 1000
#define INF 0x7fffff
#define MIN(a,b) ((a)<(b)?(a):(b))
int g[N][N],dist1[N],dist2[N],dist3[N],n,m;
char vis[N];
void dijkstra(int u,int dist[])
{
int v,i,k,min;
memset(vis,0,sizeof(vis));
for(i=0;i<n;i++) dist[i]=(i==u?0:INF);
for(i=0;i<n;i++)
{
min=INF;
for(v=0;v<n;v++) if(!vis[v]&&dist[v]<=min) min=dist[k=v];
vis[k]=1;
for(v=0;v<n;v++) dist[v]=MIN(dist[v],dist[k]+g[k][v]);
}
}
int main()
{
int i,j,t,u1,u2,u3,u,v,d,ans;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d%d%d",&n,&u1,&u2,&u3,&m);
u1--,u2--,u3--;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++) g[i][j]=g[j][i]=INF;
}
for(i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&d),u--,v--;
g[u][v]=g[v][u]=d;
}
dijkstra(u1,dist1);
dijkstra(u2,dist2);
dijkstra(u3,dist3);
ans=0;
j=u1;
for(i=0;i<n;i++)
{
if(dist1[i]>=ans&&dist1[u2]==dist1[i]+dist2[i]&&dist1[u3]==dist1[i]+dist3[i]) ans=dist1[j=i];
}
printf("%d %d %d\n",ans,dist2[j],dist3[j]);
}
return 0;
}1025: Chocolate Auction
#include<stdio.h>
#include<string.h>
int n,m,T,sum[4000000],setv[4000000],ans;
void pushdown(int rt,int l,int r)
{
int mid=(l+r)>>1;
if(setv[rt])
{
if(setv[rt]>mid)
{
setv[rt*2+1]=setv[rt];
sum[rt*2+1]=sum[rt];
}
else if(setv[rt]+sum[rt]-1<=mid)
{
setv[rt*2]=setv[rt];
sum[rt*2]=sum[rt];
}
else
{
setv[rt*2]=setv[rt];
sum[rt*2]=mid-setv[rt]+1;
setv[rt*2+1]=mid+1;
sum[rt*2+1]=setv[rt]+sum[rt]-mid-1;
}
setv[rt]=0;
}
}
void query(int rt,int l,int r,int x,int y)
{
if(x<=l&&y>=r)
{
ans+=r-l+1-sum[rt];
setv[rt]=l;
sum[rt]=r-l+1;
return;
}
pushdown(rt,l,r);
int mid=(l+r)>>1;
if(x<=mid)
query(rt*2,l,mid,x,y);
if(y>mid)
query(rt*2+1,mid+1,r,x,y);
sum[rt]=sum[rt*2]+sum[rt*2+1];
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
memset(sum,0,sizeof(sum));
memset(setv,0,sizeof(setv));
int i,a,b;
for(i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
ans=0;
query(1,1,n,a,b);
printf("%d\n",ans);
}
}
return 0;
} 1027: Smallbox魔方
#include<stdio.h>
#include<string.h>
#define MAXD 15010
#define MOD 1000000007
int N, M, a[10], b[10], ny[MAXD];
long long exgcd(long long a, long long b, long long &x, long long &y)
{
if(b == 0)
x = 1, y = 0;
else
exgcd(b, a % b, y, x), y -= x * (a / b);
}
void prepare()
{
int i;
long long x, y;
for(i = 1; i <= 15000; i ++)
{
exgcd(i, MOD, x, y);
x = (x % MOD + MOD) % MOD;
ny[i] = x;
}
}
void init()
{
int i;
scanf("%d", &N);
M = 6 * N * N;
for(i = 0; i < 6; i ++)
scanf("%d", &a[i]);
}
long long comb(int n, int m)
{
int i;
long long ans = 1;
for(i = n - m + 1; i <= n; i ++)
ans = ans * i % MOD;
for(i = 2; i <= m; i ++)
ans = ans * ny[i] % MOD;
return ans;
}
long long calculate(int m)
{
int i, j, n = 0;
long long ans = 1;
for(i = 0; i < 6; i ++)
{
if(b[i] % m != 0)
return 0;
b[i] /= m;
n += b[i];
}
for(i = 0; i < 6; i ++)
{
ans = ans * comb(n, b[i]) % MOD;
n -= b[i];
}
return ans;
}
long long frotate()
{
int i, j;
long long ans = 0;
// 0
memcpy(b, a, sizeof(a));
ans = (ans + calculate(1)) % MOD;
// 90 270
if(N & 1)
{
for(i = 0; i < 6; i ++)
for(j = 0; j < 6; j ++)
{
memcpy(b, a, sizeof(a));
-- b[i], -- b[j];
if(b[i] < 0 || b[j] < 0)
continue;
ans = (ans + 6 * calculate(4)) % MOD;
}
}
else
{
memcpy(b, a, sizeof(a));
ans = (ans + 6 * calculate(4)) % MOD;
}
// 180
if(N & 1)
{
for(i = 0; i < 6; i ++)
for(j = 0; j < 6; j ++)
{
memcpy(b, a, sizeof(a));
-- b[i], -- b[j];
if(b[i] < 0 || b[j] < 0)
continue;
ans = (ans + 3 * calculate(2)) % MOD;
}
}
else
{
memcpy(b, a, sizeof(a));
ans = (ans + 3 * calculate(2)) % MOD;
}
return ans;
}
long long erotate()
{
int i;
long long ans = 0;
// 180
memcpy(b, a, sizeof(a));
ans = (6 * calculate(2)) % MOD;
return ans;
}
long long vrotate()
{
int i;
long long ans = 0;
// 60 120
memcpy(b, a, sizeof(a));
ans = (8 * calculate(3)) % MOD;
return ans;
}
void solve()
{
long long ans = 0;
ans = (ans + frotate()) % MOD;
ans = (ans + erotate()) % MOD;
ans = (ans + vrotate()) % MOD;
ans = ans * ny[24] % MOD;
printf("%lld\n", ans);
}
int main()
{
int t;
prepare();
scanf("%d", &t);
while(t --)
{
init();
solve();
}
return 0;
}1031: Parsing Real Numbers
# include <stdio.h>
# include <ctype.h>
# include <string.h>
# define BITSET(i) ((sign)|=(char)(0x1<<(i)))
# define GETBIT(i) ((sign)>>(i) & (0x1))
char a[1000];
char sign;
/* sign: 0 - wrong?
1 - coeff sign
2 - integ
3 - digit
4 - floatdigit
5 - e
6 - e sign
7 - e integ
*/
int main()
{
int i, T, len, judge;
scanf("%d", &T);
while (T > 0)
{
scanf("%s", a);
len = strlen(a);
sign = 0;
i = 0;
if (a[i]=='+' || a[i]=='-') { BITSET(1); ++i;}
while (isdigit(a[i])) { BITSET(2); ++i;}
if (a[i]=='.') { BITSET(3); ++i;}
while (isdigit(a[i])) { BITSET(4); ++i;}
if (a[i]=='E' || a[i]=='e') { BITSET(5); ++i;}
if (a[i]=='+' || a[i]=='-') { BITSET(6); ++i;}
while (isdigit(a[i])) { BITSET(7); ++i;}
if ((a[i] != '\0')
|| (GETBIT(3) && !GETBIT(2) && !GETBIT(4))
|| ((GETBIT(5)||GETBIT(6)) && !GETBIT(7))
|| (len && !GETBIT(2) && !GETBIT(4)))
BITSET(0);
if (GETBIT(0)) printf("NO\n");
else printf("YES\n");
--T;
}
return 0;
}1032: OSU! Scoring System
#include <stdio.h>
int main()
{
int cas,com,mis,num50,num300;
scanf("%d",&cas);
double d,m,l,hsum,sum,all,num;
while(cas--)
{
scanf("%lf %lf %lf",&d,&m,&l);
hsum=0,sum=0,all=0;
com=mis=num50=num300=0;
for(int i=0;i<l;i++)
{
scanf("%lf",&num);
all+=num+num*( (com-1>0?com-1:0)*d*m )/25;
if(num==0) com=0,mis++;
else com++;
hsum+=num;
if(num==50) num50++;
if(num==300) num300++;
}
printf("%.2lf %.2lf%% ",all,hsum*100/(l*300));
double temp=hsum*100/(l*300);
if(temp==100) printf("SS\n");
else
{
double temp50=num50*50*100/(l*300);
double temp300=num300*300*100/(l*300);
if(temp300>=90 &&temp50<=1 &&mis==0)
printf("S\n");
else if(temp300>=80 &&mis==0 || temp300>=90)
printf("A\n");
else if(temp300>=70&&mis==0 ||temp300>=80)
printf("B\n");
else if(temp300>=60)
printf("C\n");
else printf("D\n");
}
}
return 0;
} 1033: 五一步行街购物
#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <cmath>
using namespace std;
typedef long long ll;
const int INF = 1e9;
int dp[110];
int m, n;
int gou[101];
int shang[100001][2], top;
int main()
{
while(scanf("%d%d",&m,&n)!=EOF)
{
if(n==0&&m==0)break;
int i, j, a, b;
map<int,bool>mp;
top = 1;
mp.clear();
for(i=1; i<=m; i++)
{
scanf("%d",&gou[i]);
mp[gou[i]] = true;
}
for(i=0; i<n; i++)
{
scanf("%d%d",&a,&b);
if(mp[a])
{
shang[top][0] = a;
shang[top][1] = b;
top++;
}
}
dp[0] = 0;
for(i=1; i<=m; i++)dp[i] = INF;
for(i=1; i<top; i++)
{
for(j=m; j>0; j--)
{
if(shang[i][0] == gou[j])
{
dp[j] = min(dp[j], dp[j-1] + shang[i][1]);
}
}
}
if(dp[m]==INF)
{
printf("Impossible\n");
}
else
{
printf("%d\n",dp[m]);
}
}
return 0;
}1034: The Composition of Letters
#include <stdio.h>
#include <string.h>
char a[100],c[100],b[100];
int ans,n,temp;
void dfs(int sum,int l,int j)
{
if(sum==ans)
{
b[j]=0;
puts(b);
temp=0;
return ;
}
for(int i=l; i<=26; i++)
if(a[i])
{
if(sum+i<=ans)
{
a[i]--;
b[j]=i+64;
dfs(sum+i,i,j+1);
a[i]++;
}
}
}
int main()
{
int cas;
char cc;
scanf("%d",&cas);
getchar();
for(int t=1; t<=cas; t++)
{
scanf("%d",&n);
memset(a,0,sizeof a);
for(int i=0; i<n; i++)
{
getchar();
scanf("%c",&cc);
a[cc-64]++;
}
scanf("%s",c);
ans=0;
for(int i=0; c[i]!=0; i++)
ans+=c[i]-'A'+1;
printf("Case %d\n",t);
temp=1;
dfs(0,0,0);
if(temp)
printf("NONE\n");
}
return 0;
} 1054: GCD depth
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <string>
#include <vector>
#include <cstdio>
#include <stack>
#include <queue>
#include <cmath>
#include <list>
#include <map>
#include <set>
#define ULL unsigned long long
#define PI 3.1415926535
#define INF 0x3f3f3f3f
#define LL long long
#define eps 1e-8
using namespace std;
int num1[200010],num2[200010];
int gcdDepth(int x,int y){
if(y==0)
return 0;
return gcdDepth(y,x%y)+1;
}
int main()
{
//freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
int x,d,y0,y1;
while(scanf("%d%d%d%d",&x,&d,&y0,&y1)!=EOF){
int ans=0;
if(x==0){
if(d==0){
if(y0==0)
ans=1;
}
else if(d==1){
if(y0==0)
ans=y1;
else
ans=y1-y0+1;
}
}
else{
int flag=0,tmp;
if(d==0){
if(y0==0)
ans=1;
flag=1;
}
for(int i=0;i<x&&!flag;++i){
tmp=gcdDepth(x,i);
if(tmp==d)
num1[i+1]=num1[i]+1;
else
num1[i+1]=num1[i];
if(tmp+2==d)
num2[i+1]=num2[i]+1;
else
num2[i+1]=num2[i];
}
tmp=y0;
if(!flag&&tmp<x){
if(y1<x){
ans+=num1[y1+1]-num1[tmp];
flag=1;
}
else{
ans+=num1[x]-num1[tmp];
tmp=x;
}
}
if(!flag&&tmp%x){
if(y1<(tmp/x+1)*x){
ans+=num2[y1%x+1]-num2[tmp%x];
flag=1;
}
else{
ans+=num2[x]-num2[tmp%x];
tmp+=x-tmp%x;
}
}
//printf("%d\n",tmp);
if(!flag)
ans+=(y1/x-tmp/x)*num2[x];
//printf("%d %d\n",tmp,(y1/x-tmp/x)*num2[x]);
if(!flag)
ans+=num2[y1%x+1];
//printf("%d\n",ans);
if(y0<=x&&y1>=x){
if(d==1)
++ans;
else if(d==2)
--ans;
}
}
printf("%d\n",ans);
}
return 0;
} 1068: Count the Number of Cycles
#include<iostream>
#include<stdio.h>
using namespace std;
const int maxn=100+5;
int a[maxn][maxn];
int main()
{
int m,n,i,j,k,s;
while(scanf("%d%d",&m,&n)!=EOF)
{
int cot=0;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
s=m-1;
for(i=0;i<s;i++)
{
int sum=0;
for(j=i+1;j<m;j++)
{
for(k=0;k<n;k++)
{sum+=a[i][k]*a[j][k];}
cot+=sum*(sum-1)/2;
sum=0;
}
}
printf("%d\n",cot);
}
return 0;
}1074: HaHa's Morning
#include<stdio.h>
#include<string.h>
using namespace std;
#define ll long long int
int n,m;
ll dp[(1<<19)];
int son[19];
int main()
{
while(~scanf("%d%d",&n,&m))
{
memset(son,0,sizeof(son));
memset(dp,0,sizeof(dp));
for(int i=0;i<m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
x--;y--;
son[x]|=(1<<y);
}
int end=(1<<n);
dp[0]=1;
for(int i=0;i<end;i++)
{
if(dp[i]>0)
{
for(int j=0;j<n;j++)
{
if((i&(son[j]))==son[j])
{
if((i&(1<<j))==0)
{
dp[(i|(1<<j))]+=dp[i];
}
}
}
}
}
printf("%lld\n",dp[end-1]);
}
}
/**********************************************************************
Problem: 1074
User: 3901140225
Language: C++
Result: AC
Time:96 ms
Memory:5216 kb
**********************************************************************/1081: 集训队分组
# include <iostream>
# include <cstdio>
# include <cstring>
# include <vector>
# define N 1005
using namespace std;
vector<int> g[N];
char vis[N];
int bfs(int u)
{
int i, cx, nx, ret;
int Q[N], front, rear;
Q[1] = u;
memset(vis, 0, sizeof(vis));
vis[u] = 1;
front = 1;
rear = 2;
ret = 0;
while (front < rear)
{
cx = Q[front++];
for (i = 0; i < g[cx].size(); ++i)
{
nx = g[cx][i];
if (!vis[nx])
{
Q[rear++] = nx;
vis[nx] = 1;
++ret;
}
}
}
return ret;
}
int main()
{
int i, n, u, v, k, m, cnt;
while (~scanf("%d%d%d", &n, &k, &m))
{
for (i = 1; i <= n; ++i) g[i].clear();
for (i = 0; i < m; ++i)
{
scanf("%d%d", &u, &v);
g[u].push_back(v);
}
cnt = 0;
for(i = 1; i <= n; ++i)
{
if (bfs(i) >= n-k) ++cnt;
if (cnt >= k) break;
}
puts(cnt>=k ? "YES":"NO");
}
return 0;
}
/**********************************************************************
Problem: 1081
User: 3901140225
Language: C++
Result: AC
Time:164 ms
Memory:2180 kb
**********************************************************************/1082: 憧憬一下集训
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstdio>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MX = 2e4 + 5;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define root 0,10000,1
int MAX[MX << 2], col[MX << 2];
struct Que {
int L, R, top, d;
bool operator<(const Que &b)const {
if(top == b.top) return d > b.d;
return top < b.top;
}
Que(int _top = 0, int _L = 0, int _R = 0, int _d = 0) {
L = _L; R = _R; top = _top; d = _d;
}
} Q[MX];
void push_up(int rt) {
MAX[rt] = max(MAX[rt << 1], MAX[rt << 1 | 1]);
}
void push_down(int rt) {
if(col[rt]) {
col[rt << 1] += col[rt];
col[rt << 1 | 1] += col[rt];
MAX[rt << 1] += col[rt];
MAX[rt << 1 | 1] += col[rt];
col[rt] = 0;
}
}
void update(int L, int R, int d, int l, int r, int rt) {
if(L <= l && r <= R) {
MAX[rt] += d;
col[rt] += d;
return;
}
int m = (l + r) >> 1;
push_down(rt);
if(L <= m) update(L, R, d, lson);
if(R > m) update(L, R, d, rson);
push_up(rt);
}
int main() {
int n;
//freopen("input.txt", "r", stdin);
while(~scanf("%d", &n)) {
memset(MAX, 0, sizeof(MAX));
memset(col, 0, sizeof(col));
for(int i = 1; i <= n; i++) {
int x1, x2, y1, y2;
scanf("%d%d%d%d", &x1, &x2, &y1, &y2);
Q[i] = Que(y1, x1, x2, 1);
Q[i + n] = Que(y2, x1, x2, -1);
}
sort(Q + 1, Q + 1 + 2 * n);
int ans = 0;
for(int i = 1; i <= 2 * n; i++) {
update(Q[i].L, Q[i].R, Q[i].d, root);
ans = max(ans, MAX[1]);
}
printf("%d\n", ans);
}
return 0;
}
/**********************************************************************
Problem: 1082
User: 3901140225
Language: C++
Result: AC
Time:812 ms
Memory:2960 kb
**********************************************************************/1086: 超市购物
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN=35;
const int MAXM=2005;
int weight[MAXN][MAXN],value[MAXN][MAXN];
int dp[MAXM];
int main()
{
int k,m;
int c=1;
while(scanf("%d%d",&k,&m)>0)
{
memset(dp,0,sizeof(dp));
memset(weight,0,sizeof(weight));
memset(value,0,sizeof(value));
for(int i=1;i<=k;i++)
{
int n;
scanf("%d",&n);
weight[i][0]=n;
for(int j=1;j<=n;j++)
scanf("%d%d",&weight[i][j],&value[i][j]);
}
for(int i=1;i<=k;i++)
for(int j=m;j>=0;j--)
for(int p=1;p<=weight[i][0];p++)
if(weight[i][p]<=j)
dp[j]=max(dp[j],dp[j-weight[i][p]]+value[i][p]);
printf("Case %d: %d\n\n",c++,dp[m]);
}
return 0;
}
/**********************************************************************
Problem: 1086
User: 3901140225
Language: C++
Result: AC
Time:64 ms
Memory:1136 kb
**********************************************************************/1087: 就多了两分钟
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int h1,m1,h2,m2;
int kase=0;
//freopen("data/1087.txt","r",stdin);
while(cin>>h1>>m1>>h2>>m2)
{
printf("Day %d: ",++kase);
if(h1>h2||h1==h2&&m1>m2)
{
cout<<"Joking"<<endl;
continue;
}
int t=(h2-h1)*60+m2-m1;
int ans=t/30;
int last=t%30;
if(last)
last=30-t%30;
if(last!=0&&last!=30)
ans++;
cout<<ans<<" "<<last<<endl;
}
return 0;
}
/**********************************************************************
Problem: 1087
User: 3901140225
Language: C++
Result: AC
Time:80 ms
Memory:2024 kb
**********************************************************************/1089: 羊吃草
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<set>
using namespace std;
#define N 100100
struct mess
{
int p;
int s;
};
mess m1[N],m2[N];
bool cmp(const mess & m1,const mess & m2)
{
return m1.s>m2.s;
}
bool operator <(const mess & m1,const mess & m2)
{
return m1.p<m2.p;
}
int main()
{
int n,m;
while(scanf("%d%d",&n,&m)!=EOF)
{
int i,j;
multiset<mess> sm;
//memset(m2,0,sizeof(m2));
for(i=0;i<n;i++)
scanf("%d%d",&m1[i].p,&m1[i].s);
for(i=0;i<m;i++)
scanf("%d%d",&m2[i].p,&m2[i].s);
sort(m1,m1+n,cmp);
sort(m2,m2+m,cmp);
long long cost=0;
j=0;
int flag=0;
for(i=0;i<n;i++)
{
while(1)
{
if(m2[j].s>=m1[i].s)
sm.insert(m2[j]); //加入优先队列
else
break;
j++;
}
if(!sm.empty())
{
multiset<mess>::iterator pos;
pos=sm.lower_bound(m1[i]); //找到满足要求的草料
if(pos!=sm.end())
{
cost+=pos->p;
sm.erase(pos);
}
else
{
flag=1;
break;
}
}
else
{
flag=1;
break;
}
}
if(flag)
printf("-1\n");
else printf("%lld\n",cost);
}
return 0;
}
/**********************************************************************
Problem: 1089
User: 3901140225
Language: C++
Result: AC
Time:588 ms
Memory:5968 kb
**********************************************************************/1090: Number Transformation
#include<stdio.h>
#include<string.h>
#define Inf 1005
#define min(a,b) a<b?a:b
int prim[200],f[608],dp[1005],p;
void prime()
{
int i,j;
memset(f,0,sizeof(f));
p = 0;
for(i = 2; i <= 605; i ++)
{
if(!f[i])
{
prim[p++] = i;
for(j = 2*i; j <= 605; j += i)
f[j] = 1;
}
}
}
int main()
{
int s,t;
int i,j,k;
prime();
while(~scanf("%d%d",&s,&t))
{
if(s < 3||t - s< 2)
{
printf("No path!\n");
continue;
}
for(i = 0; i <= t; i ++)
dp[i] = Inf;
dp[s] = 0;
for(k = s+2; k <= t; k ++)
for(j = 0; 2*prim[j] < k; j ++)
{
dp[k] = min(dp[k - prim[j]] + 1,dp[k]);
}
if(dp[t] == Inf)
printf("No path!\n");
else
printf("Need %d step(s)\n",dp[t]);
}
return 0;
}
/**********************************************************************
Problem: 1090
User: 3901140225
Language: C++
Result: AC
Time:52 ms
Memory:1128 kb
**********************************************************************/1092: Barricade
#include<iostream>
#include<climits>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=1e4+10;
const int MAXM=1e5+10;
const int INF=0x3f3f3f3f;
int head[MAXN],nxt[MAXM];
int odeg[MAXN],dist[MAXN];
bool vis[MAXN];
int n,m,en;
struct edge
{
int v,cost;
bool operator <(const edge &r) const
{
return cost>r.cost;
}
}E[MAXM];
void init()
{
memset(head,0,sizeof(head));
en=0;
memset(odeg,0,sizeof(odeg));
for(int i=1;i<=n;i++) dist[i]=INF;
}
void addedge(int u,int v)
{
E[++en].v=v;
nxt[en]=head[u];
head[u]=en;
odeg[u]++;
}
void dijkstra(int start)
{
memset(vis,false,sizeof(vis[0])*(n+5));
priority_queue<edge> q;
while(!q.empty()) q.pop();
edge now,tmp;
now.v=start;
now.cost=0;
q.push(now);
while(!q.empty())
{
now=q.top();
q.pop();
if(vis[now.v]) continue;
vis[now.v]=true;
dist[now.v]=now.cost;
for(int i=head[now.v];i;i=nxt[i])
{
int to=E[i].v;
if(!vis[to]&&dist[to]>dist[now.v]+odeg[now.v]-1)
{
dist[to]=dist[now.v]+odeg[now.v]-1;
tmp.cost=dist[to];
tmp.v=to;
q.push(tmp);
}
}
}
if(dist[n]==INF) cout<<"-1"<<endl;
else cout<<dist[n]<<endl;
}
int main()
{
ios::sync_with_stdio(false);
int u,v;
while(cin>>n>>m)
{
init();
for(int i=1;i<=m;i++)
{
cin>>u>>v;
addedge(u,v);
}
dijkstra(1);
}
return 0;
}
/**********************************************************************
Problem: 1092
User: 3901140225
Language: C++
Result: AC
Time:196 ms
Memory:3476 kb
**********************************************************************/1093: Caps Lock
#include<stdio.h>
#include<string.h>
char b1[1001][101];
int main()
{
int n,i,j,k1,k2,k3,k4,len;
while(scanf("%d",&n)!=EOF)
{
int s=0;
int d;
int kk;
k1=0;k2=0;k3=0;k4=0;
for(i=0;i<n;i++)
{
d=0;
scanf("%s",&b1[i]);
len=strlen(b1[i]);
for(j=0;j<len;j++)
if(b1[i][j]<92&&b1[i][j+1]>92||b1[i][j]>92&&b1[i][j+1]<92||b1[i][j+1]=='\0')d++; //计算一个字符串的段数
s+=d; //总段数
if(b1[i][0]>92&&b1[i][len-1]>92)k1++; //记录各类型的个数；
else if(b1[i][0]>92&&b1[i][len-1]<92)k2++;
else if(b1[i][0]<92&&b1[i][len-1]>92)k3++;
else if(b1[i][0]<92&&b1[i][len-1]<92)k4++;
}
if(k1>1) //自连
{
s-=(k1-1);
k1=1;
}
if(k4>1)
{
s-=(k4-1);
k4=1;
}
kk=k2<k3?k2:k3;
if(k2!=k3)
{
s=s-2*kk; //若有2，3类字符串s2,s3,则个数较多的放前面，如s2s3s2s3s2,则s3的首尾被连接一次，共减少2*kk次
if(k4!=0)s--;
if(k1!=0)s--;
if(k2>k3)
s--; //此时2类放前，则首字母是小写，与计算机相连
}
else
{
if(k2!=0)//2，3类间隔相连，2类放前
{
s=s-(k2+k3-1); //除了最后一个字符串，其它每个的尾字母都被连接一次
if(k4!=0)s--;
if(k1!=0)s--;
s-=1; //2类的首字母与计算机相连
}
else //2，3类都不存在,
{
if(s==1) //说明只有字符串aaa或BBBB，前者与计算机相连
{
if(k1==0)s=1;
else s=0;
}
else if(s==2)s=1; //说明只有aaa和BBB这两类字符串
else if(k1==1)s-=1;//可能是aaBBaa或BBaaBB或这两者都有，若有1类，当然1类放前，与计算机相连
}
}
printf("%d\n",s);
}
return 0;
}
/**********************************************************************
Problem: 1093
User: 3901140225
Language: C++
Result: AC
Time:12 ms
Memory:1216 kb
**********************************************************************/1098: Happy watering
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
struct note
{
int h,d;
bool operator < (const struct note &tmp)const
{
return h>tmp.h;
}
};
int main()
{
//freopen("in.txt","r",stdin);
int n,k;
while(scanf("%d%d",&n,&k)!=EOF)
{
note tmp;
int tmpmax=0;
int ans = 0x3f3f3f3f;
priority_queue<note> q;
for(int i=0;i<n;i++)
{
scanf("%d%d",&tmp.h,&tmp.d);
tmpmax = max(tmp.h,tmpmax);
q.push(tmp);
}
k++;
while(k--)
{
tmp = q.top();
q.pop();
ans = min(tmpmax-tmp.h,ans);
if(ans==0)
break;
tmp.h+=tmp.d;
tmpmax = max(tmpmax,tmp.h);
q.push(tmp);
}
printf("%d\n",ans);
}
}
/**********************************************************************
Problem: 1098
User: 3901140225
Language: C++
Result: AC
Time:116 ms
Memory:3644 kb
**********************************************************************/1101: 报数游戏
#include<cstdio>
int solve(int x)
{
if(x%7==0) return 1;
int a,flag=0;
while(x>1)
{
a=x%10;
if(a==7) {flag=1;break;}
x/=10;
}
if(flag) return 1;
return 0;
}
int main()
{
int n,m,k,a,b,y,c;
while(scanf("%d%d%d",&n,&m,&k)!=EOF)
{
if(n==0&&m==0&&k==0) break;
a=m;
if(solve(a))
{
if(k==1) {printf("%d\n",a);continue; }
else k--;
}
while(k>=1)
{
c=a;
a=a+(n-m)*2;
if(a!=c&&solve(a))
{
if(k==1) {y=a; break;}
else k--;
}
//printf("%d\n",a);
c=a;
a=a+(m-1)*2;
//printf("%d\n",a);
if(a!=c&&solve(a))
{
if(k==1) {y=a;break;}
else k--;
}
}
printf("%d\n",y);
}
return 0;
}
1102: 多连块拼图
#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;
int n,m;
char s1[20][20]; //目标字符串
char s2[20][20]; //匹配字符串
int a,b;
int c,d;
void get_big()
{
int flag=0;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(s1[i][j]=='*')
{
a=i;
b=j;
flag=1;
break;
}
}
if(flag)break;
}
}
void get_small()
{
int flag=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(s2[i][j]=='*')
{
c=i;
d=j;
flag=1;
break;
}
}
if(flag)break;
}
}
bool check()
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
if(s1[i][j]=='*')return false;
}
return true;
}
int solve()
{
get_small();
while(!check())
{
get_big();
for(int i=c;i<m;i++)
for(int j=0;j<m;j++)
{
if(s2[i][j]=='*') //开始匹配
{
if(s1[i-c+a][j-d+b]=='*')
{
s1[i-c+a][j-d+b]='.';
}
else
return 0;
}
}
}
return 1;
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
if(n==0 && m==0)break;
for(int i=0;i<n;i++)scanf("%s",s1[i]);
for(int i=0;i<m;i++)scanf("%s",s2[i]);
int ans=solve();
cout<<ans<<endl;
}
return 0;
}
1105: 打怪升级
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int n,p;
int t1[maxn],t2[maxn];
int p1[maxn],p2[maxn];
int w1[maxn],w2[maxn];
double dp[maxn][105][15];
int main()
{
while(scanf("%d %d",&n,&p),n+p)
{
for(int i = 1; i <= n; i++)
scanf("%d %d %d %d %d %d",&p1[i],&p2[i],&t1[i],&t2[i],&w1[i],&w2[i]);
for(int i = 0; i <= n; i++)
for(int j = 0; j <= 101; j++)
for(int k = 0; k <= 10; k++)
dp[i][j][k] = inf;
dp[0][p][0] = 0;
for(int i = 1; i <= n; i++)
for(int j = 0; j <= 101; j++)
for(int k = 0; k <= 10; k++)
{
if(dp[i-1][j][k] == inf) continue;
if(j < p1[i]) continue;
double T;
if(j > p2[i]) T = t2[i];
else if(j <= p2[i] && j >= p1[i]) T = t1[i] - ((j - p1[i]) * 1.0 / (p2[i] - p1[i])) * (t1[i] - t2[i] + 0.0);
int tmp = j + w1[i]; //获得的w1
int tmp2 = k + w2[i];
if(tmp > 101) tmp = 101;
if(tmp2 > 10) tmp2 = 10;
dp[i][tmp][tmp2] = min(dp[i][tmp][tmp2],dp[i-1][j][k] + T);
int tmp3 = tmp;
for(int q = 1; q <= tmp2; q++) //喝药
{
tmp3 = tmp3 * 2;
if(tmp3 > 101)
dp[i][101][tmp2 - q] = min(dp[i][101][tmp2-q],dp[i][tmp][tmp2]);
else dp[i][tmp3][tmp2 - q] = min(dp[i][tmp3][tmp2-q],dp[i][tmp][tmp2]);
}
}
double ans = inf;
for(int i = 0; i <= 101; i++)
for(int j = 0; j <= 10; j++)
ans = min(ans,dp[n][i][j]);
if(ans == inf) printf("Impossible\n");
else printf("%.2lf\n",ans);
}
return 0;
}1106: 最优对称路径
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define mod 1000000009
#define maxn 205
#define INF 0x3f3f3f3f
using namespace std;
struct node
{
int x,y,s;
} head,t;
long long dp[maxn][maxn];
int dir[4][2]= {1,0,0,1,-1,0,0,-1};
int dis[maxn][maxn];
int vis[maxn][maxn];
int v[maxn][maxn];
int n,min_dis;
int ok(int x,int y)
{
if(x<1||y<1||x+y>n+1)
return 0;
return 1;
}
void spfa()
{
memset(dis,INF,sizeof(dis));
memset(vis,0,sizeof(vis));
int tx,ty;
min_dis=INF;
queue<node>q;
q.push((node){1,1});
dis[1][1]=v[1][1];
while(!q.empty())
{
head=q.front();
q.pop();
vis[head.x][head.y]=0;
if(head.x+head.y==n+1)
{
if(dis[head.x][head.y]<min_dis)
min_dis=dis[head.x][head.y];
continue;
}
for(int i=0; i<4; i++)
{
tx=head.x+dir[i][0];
ty=head.y+dir[i][1];
if(ok(tx,ty)&&dis[tx][ty]>dis[head.x][head.y]+v[tx][ty])
{
dis[tx][ty]=dis[head.x][head.y]+v[tx][ty];
if(!vis[tx][ty])
{
vis[tx][ty]=1;
q.push((node){tx,ty});
}
}
}
}
}
long long dfs(int x,int y) //记忆化搜索
{
if(dp[x][y]!=-1)
return dp[x][y];
if(x+y==n+1)
return dp[x][y]=dis[x][y]==min_dis;
dp[x][y]=0;
int tx,ty;
for(int i=0;i<4;i++)
{
tx=x+dir[i][0];
ty=y+dir[i][1];
if(ok(tx,ty)&&(dis[x][y]+v[tx][ty]==dis[tx][ty])) //满足最短的
dp[x][y]=(dp[x][y]+dfs(tx,ty))%mod;
}
return dp[x][y];
}
int main()
{
while(~scanf("%d",&n)&&n)
{
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
{
scanf("%d",&v[i][j]);
if(i+j>n+1)
v[n+1-j][n+1-i]+=v[i][j]; //对折
}
spfa();
memset(dp,-1,sizeof(dp));
printf("%lld\n",dfs(1,1));
}
return 0;
}
1107: Pieces and Discs
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
using namespace std;
const int maxn = 41;
const int maxm = maxn * maxn;
const double eps = 1e-8;
const double pi = acos(-1.0);
int dcmp(double x)
{
if(x < -eps) return -1;
return x > eps;
}
struct Point
{
double x, y, r;
bool operator <(const Point &b)const
{
if(dcmp(x - b.x) == 0)
return y < b.y;
return x < b.x;
}
};
typedef struct
{
Point s, e;
double ang, d;
} Line;
inline double det(double x1, double y1, double x2, double y2)
{
return x1 * y2 - x2 * y1;
}
double cross(Point a, Point b, Point c)
{
return det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}
Point MakePoint(double xx, double yy)
{
Point res;
res.x = xx, res.y = yy;
return res;
}
int n, m, L, W, pnum;
vector<Point> ap;
vector<int> lp[maxn], adjp[maxm];
vector<Line> l;
vector<double> ans[maxn];
map<Point, int> M;
Point c[maxn];
bool visp[maxm];
Line SetLine(Point a, Point b)
{
Line l;
l.s = a;
l.e = b;
l.ang = atan2(b.y - a.y, b.x - a.x);
if(dcmp(a.x - b.x)) l.d = (a.x * b.y - b.x * a.y) / fabs(a.x - b.x);
else l.d = (a.x * b.y - b.x * a.y) / fabs(a.y - b.y);
return l;
}
double dotdet(double x1, double y1, double x2, double y2)
{
return x1 * x2 + y1 * y2;
}
double dot(Point a, Point b, Point c)
{
return dotdet(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}
int betweenCmp(Point a, Point b, Point c)
{
return dcmp(dot(a, b, c));
}
bool segcross(Point a, Point b, Point c, Point d, Point &p)
{
double s1, s2, s3, s4;
int d1, d2, d3, d4;
d1 = dcmp(s1 = cross(a, b, c));
d2 = dcmp(s2 = cross(a, b, d));
d3 = dcmp(s3 = cross(c, d, a));
d4 = dcmp(s4 = cross(c, d, b));
if((d1 ^ d2) == -2 && (d3 ^ d4 == -2))
{
p.x = (c.x * s2 - d.x * s1) / (s2 - s1);
p.y = (c.y * s2 - d.y * s1) / (s2 - s1);
return true;
}
if(d1 == 0 && betweenCmp(c, a, b) <= 0)
{
p = c;
return true;
}
if(d2 == 0 && betweenCmp(d, a, b) <= 0)
{
p = d;
return true;
}
if(d3 == 0 && betweenCmp(a, c, d) <= 0)
{
p = a;
return true;
}
if(d4 == 0 && betweenCmp(b, c, d) <= 0)
{
p = b;
return true;
}
return false;
}
bool CrossPoint(const Line &la, const Line &lb, Point &p)
{
return segcross(la.s, la.e, lb.s, lb.e, p);
}
bool Parallel(const Line &la, const Line &lb)
{
return !dcmp( (la.e.x - la.s.x) * (lb.e.y - lb.s.y) -
(la.e.y - la.s.y) * (lb.e.x - lb.s.x) );
}
double PolygonArea(vector<int> p)
{
if(p.size() < 4) return 0.0;
double s = ap[p[0]].y * (ap[p[p.size() - 2]].x - ap[p[1]].x);
for(int i = 1; i < p.size() - 1; ++ i)
s += ap[p[i]].y * (ap[p[i - 1]].x - ap[p[i + 1]].x);
return fabs(s * 0.5);
}
inline double CalLen(double a, double b)
{
return sqrt(a * a + b * b);
}
inline double CalDis(Point a, Point b)
{
return CalLen(a.x - b.x, a.y - b.y);
}
inline bool InCir(Point a, Point b)
{
return dcmp(CalDis(a, b) - b.r) < 0;
}
inline bool OnCir(Point a, Point b)
{
return dcmp(CalDis(a, b) - b.r) == 0;
}
double DisPtoL(Point p, Point a, Point b)
{
return fabs(cross(p, a, b)) / CalDis(a, b);
}
bool EqualPoint(Point a, Point b)
{
return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
bool SegIntersCircle(Point a, Point b, Point c)
{
Point t = c;
t.x += a.y - b.y;
t.y += b.x - a.x;
return cross(a, c, t) * cross(b, c, t) < eps &&
DisPtoL(c, a, b) - c.r < -eps;
}
bool JudgePiece(int i, vector<int> ps)
{
int j, k, cnt = 0;
for(j = 1; j < ps.size(); ++ j)
{
if(InCir(ap[ps[j]], c[i])) return true;
else if(OnCir(ap[ps[j]], c[i])) ++ cnt;
}
if(cnt >= 2) return true;
for(j = 1; j < ps.size(); ++ j)
for(k = j + 1; k < ps.size(); ++ k)
{
if(SegIntersCircle(ap[ps[j]], ap[ps[k]], c[i]))
return true;
}
for(j = 1; j < ps.size(); ++ j)
if(cross(ap[ps[j - 1]], ap[ps[j]], c[i]) < -eps) return false;
return true;
}
void FindPiece(int s0, int s1)
{
vector<int> ps;
int i, j, nex = s1, ori = s0;
double s;
ps.push_back(s0);
ps.push_back(s1);
while(nex != ori)
{
nex = -1;
for(i = 0; i < adjp[s1].size(); ++ i)
{
if(EqualPoint(ap[adjp[s1][i]], ap[s0])) continue;
if(cross(ap[s0], ap[s1], ap[adjp[s1][i]]) > -eps &&
(nex == -1 || cross(ap[s1], ap[nex], ap[adjp[s1][i]]) > eps))
nex = adjp[s1][i];
}
if(nex != -1 && (!visp[nex] || nex == ori))
ps.push_back(nex);
else return;
s0 = s1, s1 = nex;
}
s = PolygonArea(ps);
if(!dcmp(s)) return;
for(i = 0; i < m; ++ i)
if(JudgePiece(i, ps))
ans[i].push_back(s);
}
bool cmp(const int &a, const int &b)
{
if(dcmp(ap[a].x - ap[b].x) == 0)
return ap[a].y < ap[b].y;
return ap[a].x < ap[b].x;
}
int main()
{
int i, j, pnum;
double sx, sy, ex, ey;
while(scanf("%d%d%d%d", &n, &m , &L, &W), n | m | L | W)
{
l.clear();
n += 4;
M.clear();
ap.clear();
memset(visp, 0, sizeof(visp));
l.push_back(SetLine(MakePoint(0, 0), MakePoint(L, 0)));
l.push_back(SetLine(MakePoint(L, 0), MakePoint(L, W)));
l.push_back(SetLine(MakePoint(L, W), MakePoint(0, W)));
l.push_back(SetLine(MakePoint(0, W), MakePoint(0, 0)));
for(i = 4; i < n; ++ i)
{
scanf("%lf%lf%lf%lf", &sx, &sy, &ex, &ey);
l.push_back(SetLine(MakePoint(sx, sy), MakePoint(ex, ey)));
}
for(i = 0; i < m; ++ i)
scanf("%lf%lf%lf", &c[i].x, &c[i].y, &c[i].r), ans[i].clear();
for(i = 0; i < n; ++ i) lp[i].clear();
for(i = pnum = 0; i < n; ++ i)
for(j = i + 1; j < n; ++ j)
{
Point tmp;
if(CrossPoint(l[i], l[j], tmp))
{
if(!M.count(tmp))
adjp[pnum].clear(), M[tmp] = pnum ++, ap.push_back(tmp);
lp[i].push_back(M[tmp]);
lp[j].push_back(M[tmp]);
}
}
for(i = 0; i < n; ++ i)
{
sort(lp[i].begin(), lp[i].end(), cmp);
for(j = 1; j < lp[i].size(); ++ j)
{
if(!EqualPoint(ap[lp[i][j]], ap[lp[i][j - 1]]))
{
adjp[lp[i][j]].push_back(lp[i][j - 1]);
adjp[lp[i][j - 1]].push_back(lp[i][j]);
}
}
}
for(i = 0; i < pnum; ++ i)
{
if(!visp[i])
{
visp[i] = true;
for(j = 0; j < adjp[i].size(); ++ j)
if(!visp[adjp[i][j]])FindPiece(i, adjp[i][j]);
}
}
for(i = 0; i < m; ++ i)
{
sort(ans[i].begin(), ans[i].end());
printf("%d", ans[i].size());
for(j = 0; j < ans[i].size(); ++ j)
printf(" %.2f", ans[i][j]);
printf("\n");
}
printf("\n");
}
return 0;
}1110: RMQ with Shifts
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
using namespace std;
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1
const int maxn = 111111;
int minn[maxn<<2];
void pushup(int rt)
{
minn[rt] = min(minn[rt << 1], minn[rt << 1 | 1]);
}
void build(int l, int r, int rt)
{
if(l == r)
{
scanf("%d", &minn[rt]);
return;
}
int m = (l+r) >> 1;
build(lson);
build(rson);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt)
{
if(L <= l && R >= r)
return minn[rt];
int m = (l+r) >> 1;
int res = 0x3f3f3f3f;
if(m >= L) res = min(res, query(L, R, lson));
if(m < R) res = min(res, query(L, R, rson));
return res;
}
void update(int l, int r, int rt, int loc, int val)
{
if(l == r)
{
minn[rt] = val;
return;
}
int m = (l+r) >> 1;
if(m >= loc) update(lson, loc, val);
else update(rson, loc, val);
pushup(rt);
}
int main()
{
int n, q, cnt;
char s[35];
int a[30];
scanf("%d%d", &n, &q);
build(1, n, 1);
while(q--)
{
scanf("%s", s);
if(s[0] == 'q')
{
int l = 0, r = 0, i;
for(i = 6; s[i] != ','; i++)
l = l*10 + s[i]-'0';
for(i++; s[i] != ')'; i++)
r = r*10 + s[i]-'0';
printf("%d\n", query(l, r, 1, n, 1));
}
else
{
cnt = 0;
int i = 6;
while(s[i] != ')' && s[i] != '\0')//把shift的数存到a数组
{
int num = 0;
while(s[i] != ',' && s[i] != ')')
{
num = num * 10 + s[i] - '0';
i++;
}
i++;
a[cnt++] = num;
}
int tmp = query(a[0], a[0], 1, n, 1);//这几行都是在循环移动
for(int i = 0; i < cnt-1; i++)
{
int c = (i+1)%cnt;
int rr = query(a[c], a[c], 1, n, 1);
update(1, n, 1, a[i], rr);
}
update(1, n, 1, a[cnt-1], tmp);
}
}
return 0;
} 1116: Kingdoms
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define INF 0x3f3f3f3f
int map[20][20],people[20],low[20];
int n,m,p;
int vis[20];
int prim(int t,int& sum)
{
memset(vis,0,sizeof(vis));
int pos,price,tot;
pos=1; price=0; tot=0;
for(int i=1;i<=n;i++)//寻找每种情况包含的点
{
vis[i]=t&1;
t=(t>>1);
if(vis[i]) tot++;//记录有多少点
}
if(vis[1]==0) tot++;
for(int i=1;i<=n;i++)
{
if(vis[i]) low[i]=map[pos][i];
else low[i]=INF;
}
low[1]=0; vis[1]=2; tot--;//只需要将tot个点进行最小生成树就行了
int MIN;
for(int k=1;k<=tot;k++)
{
MIN=INF; pos=1;
for(int i=1;i<=n;i++)
{
if(vis[i]==1&&MIN>low[i])
{
MIN=low[i]; pos=i;
}
}
if(pos==1) return INF;//如果存在点扩展不到，就果断放弃这种情况
price+=low[pos]; sum+=people[pos]; vis[pos]=2;
for(int i=1;i<=n;i++)
{
if(vis[i]==1&&map[pos][i]<low[i])
low[i]=map[pos][i];
}
}
return price;
}
int main()
{
// freopen("s","r",stdin);
int T;
scanf("%d",&T);
while(T--)
{
memset(map,0x3f,sizeof(map));
scanf("%d%d%d",&n,&m,&p);
for(int i=1;i<=n;i++)
scanf("%d",&people[i]);//记录每个城市的人数
for(int j=1;j<=m;j++)
{
int u,v,c;
scanf("%d%d%d",&u,&v,&c);
if(c<map[u][v])//处理重边，保留花费最少的边
{
map[u][v]=map[v][u]=c;
}
}
int price,sum,res=0;
// cout<<(1<<(n-1))<<endl;
for(int i=0;i<=(1<<(n));i++)//枚举点，对每个情况找一次最小生成树
{
sum=people[1];
price=prim(i,sum);//返回总花费
if(price<=p) res=max(res,sum);//更新最大的人数
}
printf("%d\n",res);
}
return 0;
}
1117: 网格中的三角形
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline ll max(ll a, ll b) {
return a > b ? a : b;
}
inline ll min(ll a, ll b) {
return a < b ? a : b;
}
ll N, M, A, B;
ll solve (ll k) {
if (k < 0)
k = 0;
if (N > M)
swap(N, M);
ll ans = 0;
for (ll n = 1; n <= N; n++) {
for (ll m = 1; m <= M; m++) {
ll cnt = 0;
if (n * m <= k)
cnt += 2 * (n + m - 2);
ll l, r;
for (ll x = 0; x <= n; x ++) {
r = (m * x + k) / n;
if (r > m)
r = m;
ll t = m * x - k;
if(t <= 0)
l = 0;
else
l = (t - 1) / n + 1;
if(l <= r)
cnt += 2 * (r - l + 1);
}
for (ll x = 1; x < n; x++) {
ll tmp = n * m - x;
if (tmp <= k)
cnt += 4 * (m - 1);
else {
tmp = tmp - k;
ll u = m-1 - min(tmp / x + (tmp % x != 0), m-1);
cnt += 4 * u;
}
}
//printf("%lld %lld %lld\n",n , m, cnt);
ans += cnt * (N - n + 1) * (M - m + 1);
}
}
return ans;
}
int main () {
int cas;
scanf("%d", &cas);
while (cas--) {
scanf("%lld%lld%lld%lld", &N, &M, &A, &B);
printf("%lld\n", solve(B*2) - solve(A*2-1));
}
return 0;
}1119: Collecting Coins
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct node{
int x,y,flag;
};
node st[6];
node ccc[11];
int n,m;
int vis[30][30];
char map[30][30];
int zx,zy;
int cnt;
int res,ans,ans1;
int c,co;
int dir[4][2]={1,0,-1,0,0,1,0,-1};
int jude(int x,int y)
{
if(x<1||x>n||y<1||y>m) return 0;
return 1;
}
void dfs(int x,int y)
{
if(map[x][y]=='C') res++,map[x][y]='.';
vis[x][y]=1;
for(int i=0;i<4;i++)
{ int xx=x+dir[i][0];
int yy=y+dir[i][1];
if(!jude(xx,yy)||vis[xx][yy]||map[xx][yy]=='O'||map[xx][yy]=='X') continue;
dfs(xx,yy);
}
}
void dfs4(int x,int y,node *df,int &co)//推完一个石头能吃到的金币个数
{
if(map[x][y]=='C') res++,map[x][y]='.',df[co].x=x,df[co++].y=y;//记录金币的位置，后面回溯。
vis[x][y]=1;
for(int i=0;i<4;i++)
{ int xx=x+dir[i][0];
int yy=y+dir[i][1];
if(!jude(xx,yy)||vis[xx][yy]||map[xx][yy]=='O'||map[xx][yy]=='X') continue;
dfs4(xx,yy,df,co);
}
}
int dfs1(int x,int y,int zx,int zy)//判断是否能到达推石头的那个点。
{
vis[x][y]=1;
if(x==zx&&y==zy) return 1;
for(int i=0;i<4;i++)
{ int xx=x+dir[i][0];
int yy=y+dir[i][1];
if(!jude(xx,yy)||vis[xx][yy]||map[xx][yy]=='X'||map[xx][yy]=='O') continue;
if(dfs1(xx,yy,zx,zy)) return 1;
}
return 0;
}
void solove(int num,int sum)//第几个石头，金币和
{
if(num==cnt-1)//最后一个石头推完
{
if(ans1<sum) ans1=sum;
return ;
}
if(ans+ans1==c) return ;
for(int i=1;i<cnt&&ans+ans1<c;i++)//暴力枚举石头
{
if(!st[i].flag) continue ;
st[i].flag=0;
for(int j=0;j<4;j++)//枚举方向
{
int xx=st[i].x+dir[j][0];//根据你的位置得到的石头的前后位置。
int yy=st[i].y+dir[j][1];
int x2=st[i].x-dir[j][0];
int y2=st[i].y-dir[j][1];
if(!jude(xx,yy)||map[xx][yy]=='C'||map[xx][yy]=='O'||map[xx][yy]=='X') continue;//当石头后面不为空或者出界
if(!jude(x2,y2)||map[x2][y2]=='O'||map[x2][y2]=='X') continue;//当人站的那个位置还有石头或者为障碍
memset(vis,0,sizeof(vis));
if(!dfs1(zx,zy,x2,y2)) continue;//当人不能到达推石头的那个位置
map[st[i].x][st[i].y]='.';//能推就把石头那个位置变成路
map[xx][yy]='X';//石头后面的位置变成障碍
memset(vis,0,sizeof(vis));
int co=0;
node *df=(node*)malloc(sizeof(node)*10);//最多是个金币，用来保存这一轮完石头所吃的金币位置用于后面的回溯
res=0;
dfs4(zx,zy,df,co);//推完这次石头然后去吃硬币
solove(num+1,sum+res);//继续往下面枚举石头
for(int k=0;k<co;k++)//回溯地图上的金币
{
map[df[k].x][df[k].y]='C';
}
map[st[i].x][st[i].y]='O';//回溯石头的位置
map[xx][yy]='.';
}
st[i].flag=1;
if(ans1<sum) ans1=sum;//取最大
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d %d",&n,&m);
cnt=1;
c=0;
for(int i=1;i<=n;i++)
{
scanf("%s",map[i]+1);
for(int j=1;j<=m;j++)
{
if(map[i][j]=='S')
{
zx=i;
zy=j;
map[i][j]='.';
}
if (map[i][j] == 'C') c++;
if(map[i][j]=='O')
{
st[cnt].x=i,st[cnt].y=j;
st[cnt++].flag=1;
}
}
}
res=0;
memset(vis,0,sizeof(vis));
dfs(zx,zy);//不推石头直接能吃的金币个数
ans=res;
ans1=0;
solove(0,0);
printf("%d\n",ans+ans1);
}
}
1120: 病毒
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int a[1005],b[1005],dp[1005],n,m;
int LICS()
{
int i,j,MAX;
memset(dp,0,sizeof(dp));
for(i = 1; i<=n; i++)
{
MAX = 0;
for(j = 1; j<=m; j++)
{
if(a[i]>b[j] && MAX<dp[j])
MAX = dp[j];
if(a[i]==b[j])
dp[j] = MAX+1;
}
}
MAX = 0;
for(i = 1; i<=m; i++)
if(MAX<dp[i])
MAX = dp[i];
return MAX;
}
int main()
{
int T,i;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(i = 1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&m);
for(i = 1;i<=m;i++)
scanf("%d",&b[i]);
printf("%d\n",LICS());
}
return 0;
}
1128: Download Station
#include <stdio.h>
#include <string.h>
#define CLR(a) (memset(a,0,sizeof(a)))
#define N 100
char g[N][N],vis[N];
int n;
int ord[N],id[N],cnt,din[N],dout[N];
void dfs(int u)
{
int v;
vis[u]=1;
for(v=0;v<n;v++)
{
if(g[u][v]&&!vis[v]) dfs(v);
}
ord[cnt++]=u;
}
void rdfs(int u)
{
int v;
vis[u]=1,id[u]=cnt;
for(v=0;v<n;v++)
{
if(g[v][u]&&!vis[v]) rdfs(v);
}
}
void kosaraju()
{
int i,j,t,a,b;
CLR(vis);
for(i=0,cnt=0;i<n;i++)
{
if(!vis[i]) dfs(i);
}
CLR(vis);
for(t=n-1,cnt=0;t>=0;t--)
{
i=ord[t];
if(!vis[i])
{
rdfs(i),cnt++;
}
}
CLR(din),CLR(dout);
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
if((id[i]^id[j]) && (g[i][j] || g[j][i]))
{
dout[id[i]]+=g[i][j],din[id[j]]+=g[i][j];
dout[id[j]]+=g[j][i],din[id[i]]+=g[j][i];
}
}
}
for(i=0,a=0,b=0;i<cnt;i++) a+=dout[i]==0?1:0,b+=din[i]==0?1:0;
if(cnt==1) printf("0\n");
else printf("%d\n",a>b?a:b);
}
int main()
{
int i,j;
while(~scanf("%d",&n))
{
CLR(g);
for(i=0;i<n;i++)
{
while(scanf("%d",&j)&&j) g[i][j-1]=1;
}
kosaraju();
}
return 0;
}1129: 送货到家
#include<algorithm>
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
long long d[1<<15][16];
long long w[16][16],n;
int main()
{
while(scanf("%d",&n)!=EOF)
{
memset(d,0x3f3f3f3f,sizeof d);
long long ans=1e9+7;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
scanf("%lld",&w[i][j]);
if(w[i][j]==0)w[i][j]=1e9+7;
}
}
d[1][0]=0;
for(int i=1;i<(1<<n)-1;i++)
{
for(int j=0;j<n;j++)
{
if(d[i][j]==0x3f3f3f3f)continue;
if((i&(1<<j))==0)continue;
for(int k=0;k<n;k++)
{
if((i&(1<<k)))continue;
d[i|(1<<k)][k]=min(d[i|(1<<k)][k],d[i][j]+w[k][j]);
}
}
}
for(int i=0;i<n;i++)
{
ans=min(ans,d[(1<<n)-1][i]+w[i][0]);
}
if(ans>=1e9+7)puts("NoAnswer");
else printf("%lld\n",ans);
}
return 0;
}1140: 序号互换
# include <stdio.h>
# include <ctype.h>
# include <memory.h>
char a[15];
char s[15];
int main()
{
int T, i, n;
scanf("%d", &T);
while (T--)
{
scanf("%s", a);
if (isdigit(a[0]))
{
i = 0;
n = atoi(a);
while (n > 0)
{
s[i] = (n+25) % 26 + 'A';
++i;
if (n % 26) n /= 26;
else {n /= 26; --n;}
}
while (i > 0) putchar(s[--i]);
putchar('\n');
memset(s, 0, sizeof(s));
}
else
{
i = n = 0;
while (a[i] != '\0')
{
n = 26*n + a[i]-'A'+1;
++i;
}
printf("%d\n", n);
}
}
return 0;
}1156: Switching bulbs
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 100005;
int col[N] , v[N] , a[N];
bool cmp(int a , int b)
{
return a>b;
}
int main()
{
// freopen("a.in" , "r" , stdin);
int n , m;
while(scanf("%d%d" , &n , &m) == 2)
{
for(int i = 0 ; i<n ; i++)
scanf("%d" , col+i);
for(int i = 0 ; i<n ; i++)
scanf("%d" , v+i);
int val = 0;
for(int i=0 ; i<n ; i++)
if(col[i]){
val += v[i];
a[i] = -v[i];
}
else{
a[i] = v[i];
}
sort(a , a+n , cmp);
for(int i = 0 ; i<n ; i++){
if(a[i] < 0){
if(i == 0){
n = 1;
break;
}
if(-a[i] > a[i-1]) n = i;
else n = i+1;
break;
}
}
if(m<=n){
for(int i = 0 ; i<m ; i++)
val += a[i];
}
else{
for(int i = 0 ; i<n ; i++){
val += a[i];
}
if((m-n)&1) val -= a[n-1];
}
printf("%d\n" , val);
}
return 0;
}1164: Dominating
#include <algorithm>
#include<cmath>
#include<map>
#include <cstring>
#include <cstdio>
#include <iostream>
using namespace std;
map<string, int> cnt;
char s[10][20];
struct zhuan
{
int k; //记录杀人次数
int bk; //记录被杀次数
};
int c[10] = {200, 275, 325, 400, 475, 575, 675, 800, 900, 1000};
int main()
{
while((scanf("%s", s[0]))!=EOF)
{
zhuan b[10];
int z[10]; //每个人的金钱数
for(int i=0; i<10; i++) //初始化
{
b[i].bk = 0;
b[i].k = 0;
z[i] = 4726;
}
cnt[s[0]] = 0;
for(int i=1; i<10; i++)
{
scanf("%s", s[i]);
cnt[s[i]] = i;
}
int n;
scanf("%d", &n);
char a[20], e[20];
for(int i=0; i<n; i++)
{
scanf("%s%s", a, e);
if(strcmp(a, e)!=0) //非自杀
{
if((cnt[a]<5&&cnt[e]<5)||(cnt[a]>=5&&cnt[e]>=5)) //杀的是队友
{
if(z[cnt[e]]-c[b[cnt[e]].bk]>0) //被杀的金钱还够减
{
z[cnt[e]] -= c[b[cnt[e]].bk];
}
else
z[cnt[e]] = 0;
b[cnt[e]].k = 0;
b[cnt[e]].bk++;
}
else //杀的不是队友
{
if(z[cnt[e]]-c[b[cnt[e]].bk]>0)
{
if(b[cnt[a]].k>=9) //杀的人>=10
z[cnt[a]] += c[9];
else
z[cnt[a]] += c[b[cnt[a]].k];
b[cnt[a]].k++;
z[cnt[e]] -= c[b[cnt[e]].bk];
b[cnt[e]].k = 0;
b[cnt[e]].bk++;
}
else
{
if(b[cnt[a]].k>=9)
z[cnt[a]] += c[9];
else
z[cnt[a]] += c[b[cnt[a]].k];
z[cnt[e]] = 0;
b[cnt[a]].k++;
b[cnt[e]].bk++;
b[cnt[e]].k = 0;
}
}
}
}
for(int i=0; i<10; i++)
{
printf("%d\n", z[i]);
}
}
return 0;
}1174: Shining Gems
# include <stdio.h>
const int d[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
int n, m, f0, f1;
char f[1005][1005];
int check(int i, int j);
void n_swap(char *x, char *y);
int main()
{
int i, j, k, ni, nj;
while (~scanf("%d%d", &n, &m))
{
for (i = 1; i <= n; ++i)
scanf("%s", f[i]+1);
f0 = f1 = 0;
for (i = 1; !f0 && i <= n; ++i)
for (j = 1; j <= m; ++j)
{
if (check(i,j))
{
f0 = 1;
break;
}
for (k = 0; !f1 && k < 4; ++k)
{
ni = i + d[k][0];
nj = j + d[k][1];
if (ni<=n && ni>=1 && nj>=1 && nj <= m)
{
n_swap(&f[ni][nj], &f[i][j]);
if (check(ni, nj)) f1 = 1;
n_swap(&f[ni][nj], &f[i][j]);
}
}
}
if (f0) puts("Combo");
else if (f1) puts("Enjoy It");
else puts("Game Over");
}
return 0;
}
int check(int i, int j)
{
int k, cnt = 0;
char ch = f[i][j];
if ((k=i-2) <= 0) k = 1;
while (k <= n && ch != f[k][j]) ++k;
while (cnt < 3 && k <= n && ch == f[k++][j]) ++cnt;
if (cnt >= 3) return 1;
cnt = 0;
if ((k = j-2) <= 0) k = 1;
while (k <= m && ch != f[i][k]) ++k;
while (cnt < 3 && k <= m && ch == f[i][k++]) ++cnt;
if (cnt >= 3) return 1;
return 0;
}
void n_swap(char *x, char *y)
{
char ch;
ch = *x;
*x = *y;
*y = ch;
}1175: A Tour Around Hangzhou
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#define INF 0x3f3f3f
#define MAX_N 10005
#define MAX_C 15
using namespace std;
typedef pair<int,int> P;
struct edge{int to,cost;};
vector<edge> G[MAX_N];
int d[MAX_N];
int V,E;
int dijkstra(int s,int t){
priority_queue<P,vector<P>,greater<P> > que;
que.push(P(0,s));
fill(d,d+V,INF);
d[s]=0;
while(!que.empty()){
P p=que.top();que.pop();
int c=p.first,v=p.second;
if(c>d[v]) continue;
for(int i=0;i<G[v].size();i++){
edge &e=G[v][i];
int dist=c+e.cost;
if(d[e.to]>dist){
d[e.to]=dist;
que.push(P(dist,e.to));
}
}
}
return d[t];
}
int mp[MAX_C][MAX_C];
int dp[1<<MAX_C][MAX_C];
int res[MAX_C],N,se;
void slove(){
for(int S=0;S<1<<N;S++) fill(dp[S],dp[S]+N,INF);
dp[(1<<N)-1][0]=0;
for(int S=(1<<N)-2;S>=0;S--)
for(int v=0;v<N;v++)
for(int u=0;u<N;u++)
if(!(S>>u&1))
dp[S][v]=min(dp[S][v],dp[S|1<<u][u]+mp[v][u]);
if(dp[0][0]==INF) puts("What a pity");
else printf("%d\n",dp[0][0]);
}
int main()
{
int x,y,c;
while(scanf("%d%d%d",&V,&E,&N)!=EOF){
for(int i=0;i<E;i++){
scanf("%d%d%d",&x,&y,&c);
G[x].push_back(edge{y,c});
G[y].push_back(edge{x,c});
}
for(int i=0;i<N;i++)
scanf("%d",&res[i]);
scanf("%d",&se);
bool flag=false;
for(int i=0;i<N;i++)
if(res[i]==se){
swap(res[0],res[i]);
flag=true;
break;
}
if(!flag){
swap(res[0],res[N]);
res[0]=se;
N++;
}
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){
mp[i][j]=mp[j][i]=dijkstra(res[i],res[j]);
}
mp[i][i]=0;
}
slove();
for(int i=0;i<V;i++)
while(!G[i].empty())
G[i].pop_back();
}
return 0;
}1179: Sum
#include<stdio.h>
double solve(double x)
{
double k,n,n2,m;
n=double(int(x));
n2=double(int(x/2));
m=n-n2;
double sum;
sum=(1+n2)*n2*1.0/2.0-(n2+1 +n)*m*1.0/2.0+m*x;
return sum;
}
int main()
{
double x;
while(scanf("%lf",&x)==1)
printf("%.2lf\n",solve(x));
return 0;
}1182: 表达式
#include <stdio.h>
#include <string.h>
#define INI 0
#define NUM 1
#define OPT 2
#define WRN -1
#define N 1024
int table[4][130];
char s[N];
int n;
void init()
{
int state,ch;
memset(table,0xff,sizeof(table));
for(ch='0';ch<='9';ch++) table[INI][ch]=table[NUM][ch]=table[OPT][ch]=NUM;
table[INI]['+']=OPT;
table[INI]['-']=OPT;
table[NUM]['+']=OPT;
table[NUM]['-']=OPT;
table[NUM]['*']=OPT;
table[NUM]['/']=OPT;
}
int dfa(int a,int b)
{
int i,j,state=INI;
if(a>b) return WRN;
for(i=a;i<=b;i++)
{
if(s[i]==' ' || s[i]=='\t') continue;
if(s[i]=='(')
{
if(state==NUM) return WRN;
int cnt=1;
for(j=i+1;j<=b;j++)
{
if(s[j]=='(') cnt++;
else if(s[j]==')') cnt--;
if(cnt==0) break;
}
if(cnt || dfa(i+1,j-1)!=NUM) return WRN;
state=NUM;
i=j;
}
else state=table[state][s[i]];
if(state==WRN) return WRN;
}
if(state==NUM) return NUM;
return WRN;
}
int main()
{
init();
while(gets(s))
{
n=strlen(s);
if(n==0) puts("");
else printf("%s\n",dfa(0,n-1)==NUM?"Yes":"No");
}
return 0;
}1183: 计算表达式的值
#include <stdio.h>
#define MAX (100 + 10)
char szData[MAX];
void TrimSpace(char* pszData)
{
char* pszRead = pszData;
char* pszWrite = pszData;
while (*pszRead)
{
//由于数据中有\t,与先前题目描述不符合,不处理掉就直接超时了
if (*pszRead != ' ' && *pszRead != '\t')
{
*pszWrite++ = *pszRead;
}
++pszRead;
}
*pszWrite = '\0';
}
//nKind代表前一个运算符合的优先级,开始时是0,+-是1,*/是2
double Cal(char*& pszData, int nKind)
{
double fAns = 0.0;
while (*pszData && *pszData != ')')//表达式终止的条件是到达'\0'或者碰到右括号
{
if (*pszData >= '0' && *pszData <= '9')
{
fAns = 10 * fAns + *pszData - '0';
++pszData;
}
else if (*pszData == '+')
{
if (nKind >= 1)
{
return fAns;
}
++pszData;
fAns += Cal(pszData, 1);
}
else if (*pszData == '-')
{
if (nKind >= 1)
{
return fAns;
}
++pszData;
fAns -= Cal(pszData, 1);
}
else if (*pszData == '*')
{
if (nKind >= 2)
{
return fAns;
}
++pszData;
fAns *= Cal(pszData, 2);
}
else if (*pszData == '/')
{
if (nKind >= 2)
{
return fAns;
}
++pszData;
fAns /= Cal(pszData, 2);
}
else if (*pszData == '(')
{
++pszData;
fAns = Cal(pszData, 0);
++pszData;//移到')'后面
return fAns;//一个括号内的是一个完整的表达式,因此直接返回
}
}
return fAns;
}
int main()
{
while (gets(szData))
{
TrimSpace(szData);
char* pszData = szData;
printf("%.4f\n", Cal(pszData, 0));
}
}1184: 格林布的地雷
#include <stdio.h>
#include <string.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
#define N 501
int n,m,g[N][N],d[N],path[N],top;
void dfs(int u)
{
int v;
for(v=1;v<=n;v++)
{
if(g[u][v])
{
g[u][v]--;
g[v][u]--;
dfs(v);
}
}
path[top++]=u;
}
int main()
{
int i,a,b,start;
while(~scanf("%d",&m))
{
memset(g,0,sizeof(g));
memset(d,0,sizeof(d));
n=0;
for(i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
g[a][b]++;
g[b][a]++;
d[a]++;
d[b]++;
n=MAX(n,MAX(a,b));
}
for(start=1;d[start]==0 && start<=n;start++);
for(i=start;(d[i]&1)==0 && i<=n;i++);
if(i<=n) start=i;
top=0;
dfs(start);
for(i=top-1;i>=0;i--) printf("%d\n",path[i]);
}
return 0;
}1186: BMW图形文字识别
#include<stdio.h>
#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
int hash1[209][209];
int map[209][209];
int ne[209][209];
int diri[4]={0,-1,0,1};
int dirj[4]={-1,0,1,0};
int used[10099];
struct data
{
int ni,nj;
};
int n,m;
void bfs(int x,int y,int add)
{
queue<data>qq;
int i,j;
data f,s,t;
f.ni=x;
f.nj=y;
qq.push(f);
while(!qq.empty())
{
s=qq.front();
qq.pop();
for(i=0;i<=3;i++)
{
t.ni=s.ni+diri[i];
t.nj=s.nj+dirj[i];
if(t.ni>=1&&t.ni<=n&&t.nj>=1&&t.nj<=m&&(hash1[t.ni][t.nj]==0)&&map[t.ni][t.nj]==1)
{
hash1[t.ni][t.nj]=add;
qq.push(t);
}
}
}
}
int main()
{
char temp;
while(scanf("%d%d",&n,&m)!=EOF)
{
memset(hash1,0,sizeof(hash1));
memset(used,0,sizeof(used));
int i,j;
char ss[1009];
for(i=1;i<=n;i++)
{
//getchar();
scanf("%s",ss);
for(j=1;j<=m;j++)
{
temp=ss[j-1];
if(temp=='_')
map[i][j]=0;
else
map[i][j]=1;
}
}
int add=1;
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(hash1[i][j]==0&&map[i][j]==1)
{
bfs(i,j,add);
add++;
}
}
}
/*
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("%d",hash1[i][j]);
}
printf("\n");
}*/
add=1;
int k;
int B=0,M=0,W=0;
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(hash1[i][j]==0)continue;
if(used[hash1[i][j]]==1)continue;
add==hash1[i][j];
int temp=1;
for(k=j+1;k<=m;k++)
{
if(hash1[i][k]!=0&&hash1[i][k]!=add)
{
break;
}
if(hash1[i][k]!=0&&used[hash1[i][k]]==0)
{
if(hash1[i][k-1]==0)
temp++;
}
}
j=k;
used[add]=1;
if(temp==1)
{
// printf("%d %d\n",i,j);
B++;
}
if(temp==2)
M++;
if(temp==3)
W++;
add++;
}
}
printf("%d %d %d\n",B,M,W);
}
return 0;
}1196: Staginner 去爬山
#include<stdio.h>
#include<string.h>
#define N 105
int dx[] = { 0, 0, 1, -1};
int dy[] = { 1, -1, 0, 0};
int map[N][N], vis[N][N];
int n, m;
int h, maxh;
void dfs( int x, int y)
{
int newx, newy;
for( int i = 0; i < 4; i ++)
{
newx = x + dx[i];
newy = y + dy[i];
if( map[newx][newy] && !vis[newx][newy])
{
vis[newx][newy] = 1;
h = n - newx + 1;
if( maxh < h) maxh = h;
dfs( newx, newy);
}
}
}
int main()
{
while( scanf( "%d%d", &n, &m) != EOF)
{
maxh = 0;
memset( map, 0, sizeof( map) ); //这句必不可少
for( int i = 1; i <= n; i ++)
for(int j = 1; j <= m; j ++)
scanf( "%d", &map[i][j]);
memset( vis, 0, sizeof( vis) );
int i = n;
for( int j = 1; j <= m; j ++)
{
if( !vis[i][j] && map[i][j] )
{
vis[i][j] = 1;
dfs( i, j);
}
}
printf( "%d\n", maxh);
}
return 0;
}
1206: Card game
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
double dp[55][55][650];
int a[55],b[55];
int check(char ch)
{
if(ch=='A') return 1;
if(ch=='X') return 10;
if(ch=='J') return 11;
if(ch=='Q') return 12;
if(ch=='K') return 13;
return ch-'0';
}
int main()
{
int n,k,t;
scanf("%d",&t);
while(t--)
{
char str[3];
double C=1;
double f1[650],f2[650];
int sum1=0,sum2=0;
scanf("%d%d",&n,&k);
for(int i=1;i<=k;i++)
C=C*(n-i+1)/i;
for(int i=1;i<=n;i++)
{
scanf("%s",str);
a[i]=check(str[0]);
sum1+=a[i];
}
for(int i=1;i<=n;i++)
{
scanf("%s",str);
b[i]=check(str[0]);
sum2+=b[i];
}
memset(dp,0,sizeof(dp));
for(int i=0;i<=n;i++)
dp[i][0][0]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=i&&j<=k;j++)
for(int d=1;d<=sum1;d++)
{
if(d>=a[i])
dp[i][j][d]=dp[i-1][j][d]+dp[i-1][j-1][d-a[i]];
else
dp[i][j][d]=dp[i-1][j][d];
}
for(int i=1;i<=sum1;i++)
f1[i]=1.0*dp[n][k][i]/C;
memset(dp,0,sizeof(dp));
for(int i=0;i<=n;i++)
dp[i][0][0]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=i&&j<=k;j++)
for(int d=1;d<=sum2;d++)
{
if(d>=b[i])
dp[i][j][d]=dp[i-1][j][d]+dp[i-1][j-1][d-b[i]];
else
dp[i][j][d]=dp[i-1][j][d];
}
f2[0]=0.0;
for(int i=1;i<=sum1;i++)
{
f2[i]=1.0*dp[n][k][i]/C;
f2[i]+=f2[i-1];
}
double cnt=0;
for(int i=1;i<=sum1;i++)
cnt+=(double)f1[i]*f2[i-1];
printf("%.6lf\n",1.0*cnt);
}
return 0;
}1208: Fibonacci sum
#include<stdio.h>
#include<string.h>
#define MOD 1000000007
#define maxn 25
long long C[25][25];
long long ret[maxn][maxn];
long long init[maxn][maxn];
long long buf[maxn][maxn];
void matrixMul(long long a[][maxn] , long long b[][maxn] , long long n,long long mod)
{
long long i,j,k;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
buf[i][j]=0;
}
}
for(i=0;i<n;i++)
{
for(k=0;k<n;k++)
{
if(a[i][k]==0)
continue;
for(j=0;j<n;j++)
{
if(b[k][j]==0)
continue;
buf[i][j]+=a[i][k]*b[k][j];
if (buf[i][j]>=mod||buf[i][j]<=-mod)
{
buf[i][j]%=mod;
}
}
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
a[i][j]=buf[i][j];
}
}
}
void matrixMul(long long n,long long m,long long mod)
{
long long i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
ret[i][j]=(i==j);
}
}
for(;m;m>>=1)
{
if(m&1)
{
matrixMul(ret,init,n,mod);
}
matrixMul(init,init,n,mod);
}
}
void initc()
{
C[0][0]=C[1][0]=C[1][1]=1;
for(int i=2;i<=20;i++)
{
for(int j=0;j<=i&&j<=20;j++)
{
if(j==0)
C[i][j]=1;
else
C[i][j]=(C[i-1][j]+C[i-1][j-1])%MOD;
}
}
}
int main()
{
initc();
int t,n,k,i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&k);
if(n==1)
{
printf("1\n");
continue;
}
else if(n==2)
{
printf("2\n");
continue;
}
memset(init,0,sizeof(init));
for(i=0;i<=k;i++)
{
for(j=0;j<=k-i;j++)
{
init[j][i]=C[k-i][j];
}
}
for(i=0;i<=k;i++)
{
init[i][k+1]=C[k][i];
}
init[k+1][k+1]=1;
matrixMul(k+2,n-2,MOD);
long long ans=0;
for(i=0;i<=k;i++)
{
ans=(ans+ret[i][k+1])%MOD;
}
ans=(ans+2*ret[k+1][k+1])%MOD;
printf("%lld\n",ans);
}
return 0;
}1211: 大整数开平方练习
import java.util.*;
import java.math.*;
public class Main {
public static void main(String [] args)
{
Scanner input = new Scanner(System.in);
while(input.hasNext())
{
String str = input.next();
BigInteger num = new BigInteger(str);
int len = str.length();
int len1 = (len+1)/2;
BigInteger factor = BigInteger.valueOf(20);
BigInteger factor1 = BigInteger.valueOf(10);
BigInteger div = BigInteger.valueOf(0);
BigInteger ans = BigInteger.valueOf(0);
BigInteger left = BigInteger.valueOf(0);
int t = 0 , index = 0;
if(len%2 == 1){
t = str.charAt(0)-'0';
index+=1;
}else{
t = str.charAt(0)-'0';
t = t*10 + str.charAt(1)-'0';
index+=2;
}
int m = (int)Math.sqrt(t*1.0+0.1);
ans = BigInteger.valueOf(m);
div = BigInteger.valueOf(m).multiply(factor);
left = BigInteger.valueOf(t-m*m);
// System.out.println(ans);
BigInteger tmp = BigInteger.valueOf(0);
for(int i=1 ; i<len1 ; i++ , index+=2){
left = left.multiply(BigInteger.valueOf(100));
int val = str.charAt(index)-'0';
val = val*10+str.charAt(index+1)-'0';
left = left.add(BigInteger.valueOf(val));
// System.out.println("div: "+i+" "+div+" "+left);
int j=9;
for(; j>=0 ; j--){
tmp = div.add(BigInteger.valueOf(j));
if(left.compareTo(tmp.multiply(BigInteger.valueOf(j)))>=0) break;
}
left = left.subtract(tmp.multiply(BigInteger.valueOf(j)));
ans = ans.multiply(factor1).add(BigInteger.valueOf(j));
div = ans.multiply(factor);
}
System.out.println(ans);
}
}
}1219: 建食堂
#include <iostream>
#define INF 1e9
using namespace std;
const int maxn = 105;
int n,m;
int dp[maxn][maxn];
void init()
{
for(int i = 0;i < n;++i)
for(int j = 0;j < n;++j)
if(i == j) dp[i][j] = 0;
else dp[i][j] = INF;
}
bool floyd()
{
for(int k = 0;k < n;++k)
for(int i = 0;i < n;++i)
for(int j = 0;j < n;++j)
dp[i][j] = min(dp[i][k] + dp[k][j],dp[i][j]);
for(int i = 0;i < n;++i){
dp[i][n] = 0;
for(int j = 0;j < n;++j){
if(dp[i][n] >= INF) return false;
dp[i][n] = max(dp[i][j],dp[i][n]);
}
}
return true;
}
int main(void)
{
int a,b,c;
while(cin >> n >> m){
init();
while(m--){
cin >> a >> b >> c;
dp[a][b] = dp[b][a] = c;
}
bool flag = floyd();
int res = INF;
for(int i = 0;i < n;++i){
res = min(res,dp[i][n]);
}
if(flag) cout << res << endl;
else cout << "Can not" << endl;
}
return 0;
}
1226: ACM小组的内战
#include<cstdio>
#include<cstring>
#include<cstdlib>
#define SIZE 300
char s1[SIZE], s2[SIZE], s3[SIZE], s4[SIZE], a[SIZE], b[SIZE], c[SIZE], d[SIZE];
bool f1[100], f2[100];
int main()
{
while( scanf( "%s%s%s%s", s1, s2, s3, s4) == 4)
{
memset( f1, false, sizeof f1);
memset( f2, false, sizeof f2);
int len = strlen( s1);
for( int i = 0; i < len; i ++)
{
if( !f1[ s1[i] - 48 ] && !f2[ s2[i] - 48] ) {
a[ s1[i] - 48 ] = s2[i];
f1[ s1[i] - 48 ] = true;
b[ s2[i] - 48 ] = s1[i];
f2[ s2[i] - 48 ] = true;
}
if( f1[ s1[i] - 48 ] && a[ s1[i] - 48 ] != s2[i])
f1[ s1[i] - 48 ] = false;
if( f2[ s2[i] - 48 ] && b[ s2[i] - 48 ] != s1[i])
f2[ s2[i] - 48 ] = false;
}
bool flag = true;
len = strlen(s3);
for( int i = 0; i < len; i ++)
{
if( !f1[ s3[i] - 48 ]) {
flag = false;
break;
}
else
c[i] = a[ s3[i] - 48 ];
}
if( flag)
for( int i = 0; i < len; i ++)
printf( "%c", c[i]);
else
printf( "Wrong");
printf( "\n");
flag = true;
len = strlen(s4);
for( int i = 0; i < len; i ++)
{
if( !f2[ s4[i] - 48 ]) {
flag = false;
break;
}
else
d[i] = b[ s4[i] - 48];
}
if( flag)
for( int i = 0; i < len; i ++)
printf( "%c", d[i]);
else
printf( "Wrong");
printf( "\n");
}
return 0;
}1228: ACM小组的数字游戏
#include<iostream>
using namespace std;
int a[17], i, j, pos;
bool isOk(int positon)
{
if ((a[positon] < 1) || (a[positon]>16))
return false;
for (int i = 0; i < positon; i++)
if (a[i] == a[positon])
return false;
if ((positon != pos) && a[positon] == 1)
return false;
if ((positon == pos) && a[positon] != 1)
return false;
return true;
}
int main()
{
cin >> i >> j;
pos = (i - 1) * 4 + j;
for (a[1] = 1; a[1] <= 16; a[1]++)
if (isOk(1))
for (a[2] = 1; a[2] <= 16; a[2]++)
if (isOk(2))
for (a[3] = 1; a[3] <= 16;a[3]++)
if (isOk(3))
{
a[4]= 34 - a[1] - a[2] - a[3];
if (isOk(4))
for (a[5] = 1; a[5] <= 16;a[5]++)
if (isOk(5))
{
a[6] = 34 - a[1] - a[2] - a[5];
if (isOk(6))
for (a[7] = 1; a[7] <= 16;a[7]++ )
if (isOk(7))
{
a[8] = 34 - a[5] - a[6] - a[7];
if ((a[3] + a[4] + a[7] + a[8] == 34) && isOk(8))
for (a[9] = 1; a[9] <= 16; a[9]++)
if (isOk(9))
for (a[10] = 1; a[10] <= 16;a[10]++)
if (isOk(10))
{
a[11] = 34 - a[6] - a[7] - a[10];
if (isOk(11))
{
a[12] = 34 - a[9] - a[10] - a[11];
if (isOk(12))
{
a[13] = 34 - a[1] - a[5] - a[9];
if (isOk(13) && (a[4] + a[7] + a[10] + a[13] == 34))
{
a[14] = 34 - a[2] - a[6] - a[10];
{
if (isOk(14) && a[9] + a[10] + a[13] + a[14] == 34)
{
a[15] = 34 - a[3] - a[7] - a[11];
if (isOk(15))
{
a[16] = 34 - a[13] - a[14] - a[15];
if (isOk(16) && (a[11] + a[12] + a[15] + a[16] == 34) && (a[1] + a[4] + a[13] + a[16] == 34) && (a[1] + a[6] + a[11] + a[16] == 34))
{
for (int i = 1; i <=16; i++)
{
if (i % 4 != 0)
cout << a[i] << " ";
else
cout <<a[i]<< endl;
}
cout << endl;
}
}
}
}
}
}
}
}
}
}
}
return 0;
} 1230: 平面上的点
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define ll long long
void exgcd(ll a,ll b,ll &x,ll &y)
{
if(b==0)
{
x=1; y=0;
return ;
}
else
{
exgcd(b,a%b,y,x);
y=y-x*(a/b);
}
}
ll gcd(ll a,ll b)
{
return b==0?a:gcd(b,a%b);
}
ll cal(ll xx1,ll xx2,ll yy1,ll yy2,ll a,ll b,ll m)
{
///一定要保证a,b,m为非负
if(m<0)
{
m=-m; a=-a; b=-b;
}
if(a<0)
{
a=-a; ll tmp=xx1;
xx1=-xx2;
xx2=-tmp;
}
if(b<0)
{
b=-b;
ll tmp=yy1;
yy1=-yy2;
yy2=-tmp;
}
ll x0,y0,d1,t1,t2,t3,t4;
ll x1,y1;
d1=gcd(a,b);
if(m%d1!=0) return 0;
a/=d1; b/=d1; m/=d1;
exgcd(a,b,x0,y0);
x0*=m,y0*=m;
///因为是关于t的单调函数,所以对于下边界要向上取整
///对于上边界要向下取整
t1=ceil(double(xx1-x0)/b); t2=floor(double(xx2-x0)/b);
t3=ceil(double(y0-yy2)/a); t4=floor(double(y0-yy1)/a);
t1=max(t1,t3); t2=min(t2,t4);
if(t2<t1) return 0;
return t2-t1+1;
}
int main()
{
//freopen("in.txt","r",stdin);
//freopen("test.txt","w",stdout);
ll a,b,c,d;
ll x1,x2,y1,y2,z1,z2;
while(scanf("%lld%lld%lld%lld",&a,&b,&c,&d)!=EOF)
{
scanf("%lld%lld%lld%lld%lld%lld",&x1,&x2,&y1,&y2,&z1,&z2);
if(a==0&&b==0)
{
ll cnt=0;
for(int z=z1;z<=z2;z++)
{
if(c*z+d==0)
cnt++;
}
cnt*=(x2-x1+1)*(y2-y1+1);
printf("%lld\n",cnt);
continue;
}
if(a==0)
{
ll cnt=0;
for(int z=z1;z<=z2;z++)
{
ll tmp=-1*(d+c*z);
if(tmp%b==0&&tmp/b>=y1&&tmp/b<=y2)
cnt++;
}
cnt*=(x2-x1+1);
printf("%lld\n",cnt);
continue;
}
if(b==0)
{
ll cnt=0;
for(int z=z1;z<=z2;z++)
{
ll tmp=-1*(c*z+d);
if(tmp%a==0&&tmp/a>=x1&&tmp/a<=x2)
cnt++;
}
cnt*=(y2-y1+1);
printf("%lld\n",cnt);
continue;
}
ll ans=0;
for(int z=z1;z<=z2;z++)
{
ll m=-1*(d+c*z);
ans+=(cal(x1,x2,y1,y2,a,b,m));
}
printf("%lld\n",ans);
}
return 0;
}1232: 懒汉的旅行
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <sstream>
#include <algorithm>
//#include <map>
#include <set>
#include <cmath>
#include <bitset>
#define INF 0x3f3f3f3f
using namespace std;
struct edge{
int v;int len;
};
struct status{
int step,cost,u,oil;
bool operator < (const status &b) const
{
if(step != b.step) return step > b.step;
else if(cost != b.cost) return cost > b.cost;
else if(oil != b.oil) return oil < b.oil;
}
}mark[105];
vector<edge> vec[105];
int N,M,L,Y;
int start,finish;
int bfs()
{
priority_queue<status> q;
q.push((status){0,0,start,L}) ;
while(!q.empty())
{
status now = q.top();
q.pop();
bool f = false;
if(now.cost<mark[now.u].cost) f = true,mark[now.u]=now;
if(now.step<mark[now.u].step) f = true, mark[now.u]=now;
if(now.oil>mark[now.u].oil) f = true, mark[now.u]=now;
if(!f)continue;
if(now.u == finish)
return now.cost;
for(auto &Next : vec[now.u])
{
status tmp = now;
tmp.u = Next.v;
if(Next.len > L)
continue;
if(tmp.oil >= Next.len)
q.push((status){now.step,now.cost,Next.v,now.oil-Next.len});
q.push((status){now.step+1,now.cost+Y*(L-now.oil),Next.v,L-Next.len});
}
}
return -1;
}
int main()
{
while(scanf("%d%d%d%d",&N,&M,&L,&Y) != EOF)
{
for(int i = 0 ; i <= N ; i++)
mark[i]=(status){INF,INF,i,-1},vec[i].clear();
scanf("%d%d",&start,&finish);
for(int i = 0 ; i < M ; i++)
{
int u,v,l;
scanf("%d%d%d",&u,&v,&l);
vec[u].push_back((edge){v,l});
vec[v].push_back((edge){u,l});
}
printf("%d\n",bfs());
}
return 0;
}1233: 病毒的复制
# include <stdio.h>
# define MAX 1000003
typedef struct Matrix
{
long long a,b;
long long c,d;
} matrix;
long long x[2], t;
int solve(matrix mat)
{
int tot;
matrix cur, cross, tmp;
cur = mat;
if (t & 0x1) cross = cur;
else
{
cross.a = cross.d = 1;
cross.b = cross.c = 0;
}
while (t>0)
{
t >>= 1;
tmp = cur;
cur.a = (tmp.a*tmp.a+tmp.b*tmp.c) % MAX;
cur.b = (tmp.b*(tmp.a+tmp.d)) % MAX;
cur.c = (tmp.c*(tmp.a+tmp.d)) % MAX;
cur.d = (tmp.d*tmp.d+tmp.b*tmp.c) % MAX;
tmp = cross;
if (t & 0x1)
{
cross.a = (tmp.a*cur.a+tmp.b*cur.c) % MAX;
cross.b = (tmp.a*cur.b+tmp.b*cur.d) % MAX;
cross.c = (tmp.c*cur.a+tmp.d*cur.c) % MAX;
cross.d = (tmp.c*cur.b+tmp.d*cur.d) % MAX;
}
}
tot = (int)((cross.a*x[0]+cross.b*x[1]+cross.c*x[0]+cross.d*x[1])%MAX);
return tot;
}
int main()
{
int tot;
matrix mat;
while (~scanf("%Illd%lld%lld%lld%lld%lld%lld", &x[0],&x[1],&mat.a,&mat.c,&mat.b,&mat.d,&t))
{
tot = solve(mat);
printf("%d\n", tot);
}
return 0;
}1238: 兵临城下
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int const maxn=31000;
long long Min[maxn*4],Max[maxn*4];
void Build(int rt,int l,int r)
{
if(l>=r)
{
Min[rt]=0;
return ;
}
int m=(l+r)/2;
Build(rt*2,l,m);
Build(rt*2+1,m+1,r);
Min[rt]=min(Min[2*rt],Min[2*rt+1]);
}
void update(int rt,int l,int r,int x,int num)
{
if(l>=r)
{
Min[rt]=num;
return ;
}
int m=(l+r)/2;
if(m>=x)
update(rt*2,l,m,x,num);
if(m<x)
update(rt*2+1,m+1,r,x,num);
Min[rt]=min(Min[rt*2],Min[2*rt+1]);
}
long long query(int rt,int l,int r,int ql,int qr)
{
long long ans=0x7fffffff;
if(ql<=l&&qr>=r)
{
return Min[rt];
}
int m=(l+r)/2;
if(m>=ql)
ans=min(ans,query(rt*2,l,m,ql,qr));
if(m<qr)
ans=min(ans,query(rt*2+1,m+1,r,ql,qr));
return ans;
}
int main()
{
//freopen("test0.in","r",stdin);
//freopen("out.txt","w",stdout);
int n,t,p;
while(scanf("%d%d%d",&n,&t,&p)!=EOF)
{
memset(Min,0,sizeof(Min));
while(p--)
{
int x,y;
char str[10];
scanf("%d%s",&x,str);
if(str[0]=='p')
{
int l=1,r=n;
int tmp;
while(l<=r)
{
int m=(l+r)/2;
if(query(1,1,n,l,m)<=x)
r=m-1,tmp=m;
else
l=m+1;
}
update(1,1,n,tmp,x+t*60);
printf("%d\n",tmp);
}
else
{
scanf("%d",&y);
int k=query(1,1,n,y,y);
//cout<<k<<endl;
if(k<=x)
printf("Cannot\n");
else
{
printf("Fire!\n");
update(1,1,n,y,x+t*60);
}
}
}
}
return 0;
}1239: 审阅文稿
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
char st1[20001],st2[12000001];
int nextt[1000001];
bool equ(int i,char a[],int j,char b[])
{
if(a[i]==b[j]&&a[i+1]==b[j+1]) return true;
return false;
}
void getnext()
{
int i,j,len=strlen(st1);
nextt[0]=-2;i=0;j=-2;
while(i<len)
{
if(j==-2||equ(i,st1,j,st1))
{
i+=2;j+=2;//++i;++j;
if(!equ(i,st1,j,st1)) nextt[i>>1]=j;
else nextt[i>>1]=nextt[j>>1];
}
else j=nextt[j>>1];
}
}
void kmp()
{
int i=0,j=0;
getnext();
int l1=strlen(st1),l2=strlen(st2);
int ans=0;
while(i<l2)
{
if(j==-2||equ(j,st1,i,st2))
i+=2,j+=2;
else j=nextt[ j>>1 ];
if(j==l1) ++ans,j=nextt[j>>1];
}
cout<<ans<<endl;
}
int main()
{
while(scanf("%s",st1)!=EOF){
scanf("%s",st2);
kmp();
}
return 0;
}1241: 数字序列
1241: 数字序列#include <cstdio>
#include <cstring>
int vis[10010],num[10010],r[10010],fa[10010];//vis表示该头目节点是否访问过 num[i]表示i作为头目节点所表示的数，但不是确切的数，相对于集体来讲的 r[i]表示i节点与头目节点的相对值 fa[i]是i的父节点
int find(int x) //压缩路径，并且使得r[i]等于i相对于根节点的值的大小
{
if(x==fa[x])
{
return x;
}
int tmp=fa[x];
fa[x]=find(fa[x]);
r[x]=r[x]+r[tmp];
return fa[x];
}
int main()
{
int n,m;
while(scanf("%d%d",&n,&m)!=EOF)
{
char op[2];
memset(vis,0,sizeof(vis));
memset(num,0,sizeof(num));
for(int i=1;i<=n;i++)
{
fa[i]=i;
r[i]=0;
}
int flag=0;
for(int i=0;i<m;i++)
{
scanf("%s",op);
if(op[0]=='B')
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
int fx=find(a);
int fy=find(b);
if(fx!=fy)//两集体合并
{
fa[fy]=fx;
r[fy]=r[a]-r[b]-c;//更新b的头目节点相对于a的头目节点的大小
if(vis[fy])//如果b的集体已经有确切的值了
{
int tmp=num[fy]-r[fy];
if(vis[fx])//如果a集体也已经有确切的值了
{
if(num[fx]!=tmp)//
{
flag=1;
}
}
else
{
num[fx]=tmp;
vis[fx]=1;
}
}
}
else//ab是一个集体中的
{
if(r[a]-r[b]!=c)
{
flag=1;
}
}
}
else
{
int a,b;
scanf("%d%d",&a,&b);
int fx=find(a);
int tmp=b-r[a];
if(vis[fx])
{
if(num[fx]!=tmp)
{
flag=1;
}
}
else
{
num[fx]=tmp;
vis[fx]=1;
}
}
}
if(flag)
{
printf("RE\n");
}
else
{
for(int i=1;i<=n;i++)
{
if(find(i)==i&&vis[i]==0)
{
flag=1;
break;
}
}
if(flag)
{
printf("WA\n");
}
else
{
printf("AC\n");
}
}
}
return 0;
} 1244: 琼脂糖双向免疫扩散试验
#include<stdio.h>
#include<math.h>
#define EPS 1e-5
int main()
{
double rg,rb,cg,cb,d,t,s,res;
while(scanf("%lf%lf%lf%lf%lf%lf%lf",&rb,&rg,&cb,&cg,&d,&t,&s)!=EOF)
{
///directly calculate
res=s*rg*cg/rb/cb+1.0;
res=d/res;
///判断条件上WA了几次，精度没必要用EPS的
if(rb-res>=0.0000||d-rg-res<=0.0000||(rb*cb-res*t<EPS))
printf("Can not\n");
else
printf("%.4lf\n",res);
}
return 0;
}1245: 信使核糖核酸转录后剪接
#include<stdio.h>
#include<string.h>
#define N 1000010
char t(char c)
{
if(c=='A')
return 'U';
if(c=='G')
return 'C';
if(c=='C')
return 'G';
if(c=='T')
return 'A';
}
char dna[N],mrna[N];
int main()
{
int i,j,la,lb,f;
while(scanf("%s%s",dna,mrna)!=EOF)
{
la=strlen(dna);
lb=strlen(mrna);
f=1;
for(i=0;i<la;++i)
dna[i]=t(dna[i]);
if(la<lb)
f=0;
else
for(i=la-1,j=0;j<lb;--i,++j)
{
for(;i>=0&&(dna[i]!=mrna[j]);--i);
if(i==-1)
{
f=0;//表示匹配失败
break;
}
}
if(f)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}1246: 十二指肠钩口线虫
#include<stdio.h>
int main()
{
int s,v,t,m,e;
while(scanf("%d%d%d%d%d",&s,&v,&t,&m,&e)!=EOF)
{
int res=e*s;
int n=e/t;///完成吸血的个数
int f=(e-m)/t;///完成渗血的个数
if(f<0)
f=0;
res+=f*m*v;
for(int i=f+1;i<=n;++i)
res+=(e-i*t)*v;
printf("%d\n",res);
}
return 0;
}1247: 有髓鞘神经纤维动作电位传导
#include<stdio.h>
#include<string.h>
#define N 10001
int main()
{
int n,t1,t2,l,k,u,i,j;
int pre[N],tim[N],hasNext[N],allTime;
while(scanf("%d%d%d",&n,&t1,&t2)!=EOF)
{
memset(hasNext,0,(n+1)*sizeof(int));
for(i=1;i<=n;++i)
{
scanf("%d%d%d",&u,&l,&k);
pre[i]=u;
hasNext[u]=1;
if(k)
{
int a,b;
scanf("%d",&a);
tim[i]=a;
for(j=1;j<k;++j)
{
scanf("%d%d",&a,&b);
tim[i]+=b-a;
}
scanf("%d",&b);
tim[i]+=l-b;
tim[i]=tim[i]*t1+t2;
}
else
tim[i]=l*t1+t2;
}
int minn=1<<30,minInd,maxx=0,maxInd;
for(i=1;i<=n;++i)
{
if(!hasNext[i])
{
allTime=0;
j=i;
while(j!=0)
{
allTime+=tim[j];
j=pre[j];
}
if(allTime<minn)
{
minn=allTime;
minInd=i;
}
if(allTime>maxx)
{
maxx=allTime;
maxInd=i;
}
}
}
printf("%d %d\n",minInd,maxInd);
}
return 0;
}
1248: 非变性聚丙烯酰胺凝胶电泳
#include<stdio.h>
#include<string.h>
#define N 2001
int mass[N];
bool dp[N];
int main()
{
int n,m,i,j;
while(scanf("%d%d",&n,&m)!=EOF)
{
m-=18;
for(i=0;i<n;++i)
{
scanf("%d",&mass[i]);
mass[i]-=18;
}
memset(dp,0,sizeof(dp));
dp[0]=1;
for(i=0;i<n;++i)
{
for(j=(m<<1);j>=mass[i];--j)
dp[j]=dp[j]||dp[j-mass[i]];
}
for(i=0;;i++)
if(dp[m-i]||dp[m+i])
{
if(dp[m-i])
j=m+18-i;
else if(dp[m+i])
j=m+18+i;
break;
}
printf("%d\n",j);
}
return 0;
}1249: 竞争性酶抑制剂和同工酶
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
#define N 155
#define INF 1<<30
int n,m,f[N][N];
int s,e,c,pre[N];
int bfs()
{
queue< int > q;
memset(pre,-1,sizeof(pre));
q.push(s);
pre[s]=0;
int k,i,inc=INF;
while(!q.empty())
{
k=q.front();
q.pop();
for(i=1;i<=n;++i)
if(i!=s&&pre[i]==-1&&f[k][i])
{
pre[i]=k;
q.push(i);
inc=min(inc,f[k][i]);
if(i==e)
return inc;
}
}
return 0;
}
int flow()
{
int res=0;
while(1)
{
int inc=bfs();
if(inc==0)
break;
res+=inc;
int i=e,j;
for(;i!=s;)
{
j=pre[i];
f[j][i]-=inc;
f[i][j]+=inc;
i=j;
}
}
return res;
}
int main()
{
while(scanf("%d%d",&n,&m)==2)
{
memset(f,0,sizeof(f));
while(m--)
{
scanf("%d%d%d",&s,&e,&c);
f[s][e]+=c;
}
scanf("%d%d",&s,&e);
for(int i=1;i<=n;++i)
f[e][i]=f[i][s]=0;
printf("%d\n",flow());
}
return 0;
}1256: 天朝的单行道
#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=5005,maxm=20005,INF=1<<30;
int n,m,e;
// v存储对应有向边的终点，nxt存储当前边起点相连的下一条边的编号
// first存储对应起点的第一条边的编号，dis存储当前状态下的从起点
// 开始到当前点的最小权重和（一直在更新），inq储存是否在队列
// 中的标记 ，w储存对应边的权重
int v[maxm],nxt[maxm],w[maxm],first[maxn],dis[maxn],inq[maxn],fa[maxn];
int find(int a){return fa[a]==a?a:fa[a]=find(fa[a]);}
bool merge(int a, int b){
int faa=find(a),fab=find(b);
if(faa==fab)return false;
fa[fab]=faa;
return true;
}
void add(int a, int b, int c){
v[e]=b;
nxt[e]=first[a];
w[e]=c;
first[a]=e++;
}
void spfa(int source){
queue<int> q;
dis[source]=0;
inq[source]=1;
q.push(source);
while(!q.empty()){
int tmp=q.front();
q.pop();
inq[tmp]=0;
for(int i = first[tmp]; i != -1; i=nxt[i]){
if(dis[v[i]]>dis[tmp]+w[i]){
dis[v[i]]=dis[tmp]+w[i];
if(!inq[v[i]]){
q.push(v[i]);
inq[v[i]]=1;
}
}
}
}
}
int main(){
while(~scanf("%d%d",&n,&m)){
e=0;
memset(first,-1,sizeof(first));
memset(inq,0,sizeof(inq));
for(int i = 0; i < maxn; i++)dis[i]=INF;
for(int i = 0; i <= n; i++)fa[i]=i;
for(int i = 0; i < m; i++){
int a,b;
scanf("%d%d",&a,&b);
add(a,b,0);
add(b,a,1);
merge(a,b);
}
if(find(1)==find(n))
spfa(1);
if(dis[n]==INF)
printf("-1\n");
else
printf("%d\n",dis[n]);
}
return 0;
}1258: 维护序列
#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std ;
#define MAXN 10005
#define M(x , y) (x+y)>>1
#define L(x) x<<1
#define R(x) x<<1|1
struct Tree{
int l ;
int r ;
int sum ;
int lazy;
}tree[MAXN * 4] ;
int n ;
int m ;
inline void pushup(int c){
int l = L(c) ;
int r = R(c) ;
tree[c].sum = tree[l].sum ^ tree[r].sum ;
if(tree[l].lazy && tree[r].lazy)
tree[c].lazy = 1 ;
}
void build(int l ,int r , int c){
tree[c].l = l ;
tree[c].r = r ;
tree[c].sum = 0 ;
tree[c].lazy = 0 ;
if(l == r)
return ;
build( l , M(l, r) , L(c)) ;
build( (M(l , r)) + 1 , r , R(c)) ;
}
void insert(int v , int l , int c){
if(tree[c].l == l && tree[c].r==l){
tree[c].sum = v ;
if(!v)
tree[c].lazy = 1 ;
return ;
}
int m = M(tree[c].l , tree[c].r) ;
if(l <= m){
insert(v , l , L(c)) ;
}
else{
insert(v , l , R(c)) ;
}
pushup(c) ;
}
void update(int l , int r , int c){
if(tree[c].lazy)
return ;
if(l == r && tree[c].l==tree[c].r && l==tree[c].l){
if(tree[c].sum != 0){
int k = tree[c].sum & (-tree[c].sum) ;
tree[c].sum = tree[c].sum^k ;
if(!tree[c].sum){
tree[c].lazy = 1 ;
}
}
return ;
}
int m = M(tree[c].l , tree[c].r) ;
if(l==tree[c].l && r == tree[c].r){
update(l , m , L(c) ) ;
update(m + 1 , r , R(c)) ;
}
else if(m >= r){
update(l , r , L(c)) ;
}
else if(m < l){
update(l , r , R(c)) ;
}
else {
update(l , m , L(c)) ;
update(m+1 , r , R(c)) ;
}
pushup(c) ;
}
void query(int &ans , int l , int r , int c){
if(tree[c].lazy){
ans ^= 0 ;
return ;
}
if(tree[c].l == l && tree[c].r == r){
ans ^= tree[c].sum ;
return ;
}
int m = M(tree[c].l , tree[c].r) ;
if(r <= m){
query(ans , l , r , L(c)) ;
}
else if(l > m){
query(ans , l , r , R(c)) ;
}
else{
query(ans , l , m , L(c)) ;
query(ans , m + 1 , r , R(c)) ;
}
}
int main(){
while(scanf("%d%d" , &n , &m) != EOF){
int x ;
int y ;
int k ;
build(1 , n , 1) ;
for(int i = 1 ; i <= n ; i ++){
scanf("%d" , &x) ;
insert(x , i , 1 ) ;
}
for(int i = 1 ; i <= m ; i ++){
scanf("%d%d%d" , &k , &x , &y) ;
if(k == 1){
update(x , y , 1) ;
}
else{
int ans = 0 ;
query(ans , x , y , 1) ;
printf("%d\n" , ans) ;
}
}
}
return 0 ;
}
1259: 跳跳
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct stu
{
int i,j;
};
int a[101][101],m;
char s[101][101];
queue<struct stu> q;
void xtd(int i,int j)
{
struct stu n;
int i1,j1;
if(s[i][j]>='2'&&s[i][j]<='9')
for(i1=0;i1<m;i1++)
for(j1=0;j1<m;j1++)
if(s[i1][j1]==s[i][j]&&!a[i1][j1]){
n.i=i1;
n.j=j1;
q.push(n);
a[i1][j1]=a[i][j];
}
}
int bfs(struct stu n)
{
int i,j,flag=0;
q.push(n);
a[n.i][n.j]=1;
while(!q.empty()){
n=q.front();
i=n.i;
j=n.j;
q.pop();
if(s[i][j]=='E'){
flag=1;
break;
}
if(s[i][j]!='1'){
if(i-1>=0&&s[i-1][j]!='1'&&!a[i-1][j]){
n.i=i-1;
n.j=j;
q.push(n);
a[i-1][j]=a[i][j]+1;
xtd(i-1,j);
}
if(i+1<m&&s[i+1][j]!='1'&&!a[i+1][j]){
n.i=i+1;
n.j=j;
q.push(n);
a[i+1][j]=a[i][j]+1;
xtd(i+1,j);
}
if(j-1>=0&&s[i][j-1]!='1'&&!a[i][j-1]){
n.i=i;
n.j=j-1;
q.push(n);
a[i][j-1]=a[i][j]+1;
xtd(i,j-1);
}
if(j+1<m&&s[i][j+1]!='1'&&!a[i][j+1]){
n.i=i;
n.j=j+1;
q.push(n);
a[i][j+1]=a[i][j]+1;
xtd(i,j+1);
}
}
}
return flag;
}
int main()
{
int i,j,t;
struct stu n,k;
while(scanf("%d",&m)!=EOF){
getchar();
for(i=0;i<m;i++){
for(j=0;j<m;j++){
scanf("%c",&s[i][j]);
if(s[i][j]=='S'){
n.i=i;
n.j=j;
}
else if(s[i][j]=='E'){
k.i=i;
k.j=j;
}
}
getchar();
}
memset(a,0,sizeof(a));
while(!q.empty())
q.pop();
t=bfs(n);
if(t)
printf("%d\n",a[k.i][k.j]-1);
else
printf("Oh No!\n");
}
return 0;
}1262: 安全密码
#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;
int main()
{
#ifdef LOCAL
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
#endif
char s[55];
int a1,a2,a3,a4;
while(scanf("%s",s)!=EOF)
{
a1=0;a2=0;a3=0;a4=0;
int l=strlen(s);
for(int i=0;i<l;i++)
{
if(l<8)
break;
if(s[i]>=65&&s[i]<=90)
a1++;
else if(s[i]>=97&&s[i]<=122)
a2++;
else if(s[i]>=48&&s[i]<=57)
a3++;
else
a4++;
}
if(a1*a2*a3||a1*a2*a4||a1*a3*a4||a2*a3*a4)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}1264: 惠民工程
#include<cstdio>
#include<cstring>
#include<stdlib.h>
#include<algorithm>
using namespace std;
int pre[1005];
struct node
{
int p1;
int p2;//p1,p2分别对应的两个居民点
int v;//铺设管道所需的费用
} way[1005];
int m,n;
void init()
{
memset(pre,0,sizeof(pre));
memset(way,0,sizeof(way));
for(int i=1;i<=m;i++)//初始化，每一个点当做是一个父节点
pre[i]=i;
}
int cmp(node a,node b)
{
return a.v<b.v;
}
int find(int x)//查找父节点
{
int ret=x;
while(pre[ret]!=ret) //如果查找到的父节点不是它本身，就直接把它当做一个新的父节点
ret=pre[ret];
int t=x,r;//下面是路径压缩
while(t!=ret)
{
r=pre[t]; //在改变上一级额的父节点之前 用临时变量将它记录起来
pre[t]=ret;//把上级节点改为父节点
t=r;
}
return ret;
}
int join(int x,int y) //判断两个点是否连通
{
int fx=find(x);
int fy=find(y);
if(fx!=fy)//如果已经联通就不用管，否则将它并入之前的连通分支中
{
pre[fx]=fy;
return 1;
}
return 0;
}
int main()
{
while(~scanf("%d%d",&m,&n))
{
init();
for(int i=0;i<n;i++)
scanf("%d%d%d",&way[i].p1,&way[i].p2,&way[i].v);
sort(way,way+n,cmp); //排序，目的是为了优先考虑成本低的将它并入连通分支
int ans=0;
for(int i=0;i<n;i++)
if(join(way[i].p1,way[i].p2))//如果已经联通就只需计算管道费用就行
ans+=way[i].v;
int count=0;
for(int i=1;i<=m;i++)
if(pre[i]==i)//判断是否都连通
count++;
if(count>1)//如果不连通
printf("?\n");
else
printf("%d\n",ans);
}
return 0;
}
1268: Pingpang Balls
#include<stdio.h>
int abs(int a, int b)
{
if(a >= b)
return a - b;
else
return b -a;
}
int main()
{
int N, S, D1, D2, D3, T, W[25], i, flag1, flag2, flag3;
scanf("%d", &T);
while(T --)
{
i = flag1 = flag2 = flag3 = 0;
scanf("%d%d%d%d%d", &N, &S, &D1, &D2, &D3);
for(i = 0; i < N; i ++)
scanf("%d", &W[i]);
for(i = 0; i < N; i ++)
{
if(abs(W[i], S) <= D1)
flag3 ++;
else if(abs(W[i], S) > D1 && abs(W[i], S) <= D2)
flag2 ++;
else if(abs(W[i], S) > D2 && abs(W[i], S) <= D3)
flag1 ++;
}
printf("%d %d %d\n", flag3, flag2, flag1);
}
return 0;
}1269: Morse Code Wristwatch
#include<stdio.h>
#include<algorithm>
using namespace std;
char mp[20][25];
int aa[25]= {0,1,2,0,0,0};
int pp[25]= {0,1,2,2,1,0};
int mm[25]= {0,2,2,0,0,0};
int num[15][9]= {{0,2,2,2,2,2},{0,1,2,2,2,2},{0,1,1,2,2,2},{0,1,1,1,2,2},{0,1,1,1,1,2},{0,1,1,1,1,1},{0,2,1,1,1,1},{0,2,2,1,1,1},{0,2,2,2,1,1},{0,2,2,2,2,1},};
void dian(int n,char c)
{
for(int i=1; i<=5; i++)
mp[i][n]=c;
}
void doit(int biao,char c)
{
int *p;
if(c=='A')
p=aa;
else if(c=='M')
p=mm;
else if(c=='P')
p=pp;
else
p=num[c-'0'];
for(int i=1; i<=5; i++)
{
if(p[i]==1)
{
mp[i][biao]='#';
mp[i][biao+1]='.';
}
if(p[i]==2)
{
mp[i][biao]='#';
mp[i][biao+1]='#';
}
if(p[i]==0)
{
mp[i][biao]='.';
mp[i][biao+1]='.';
}
}
}
int main()
{
char s[200];
int t;
scanf("%d",&t);
getchar();
while(t--)
{
gets(s);
int biao=1;
for(int i=0; s[i]!=0; i++)
{
if(s[i]!=' ')
{
dian(biao++,'.');
doit(biao,s[i]);
biao+=2;
}
}
for(int i=1; i<=5; i++)
{
for(int j=1; j<=18; j++)
{
printf("%c",mp[i][j]);
}
puts("");
}
puts("");
}
return 0;
}1272: Karma
1272: Karma#include <stdio.h>
#include <math.h>
#include <string.h>
#include <algorithm>
using namespace std;
const double eps = 1e-8;
const double PI = acos(-1.0);
int sgn(double x)
{
if(fabs(x) < eps)return 0;
if(x < 0)return -1;
else return 1;
}
struct Point
{
double x,y;
Point() {}
Point(double _x,double _y)
{
x = _x;
y = _y;
}
Point operator -(const Point &b)const
{
return Point(x - b.x,y - b.y);
}
//叉积
double operator ^(const Point &b)const
{
return x*b.y - y*b.x;
}
//点积
double operator *(const Point &b)const
{
return x*b.x + y*b.y;
}
//绕原点旋转角度B（弧度值），后x,y的变化
void transXY(double B)
{
double tx = x,ty = y;
x = tx*cos(B) - ty*sin(B);
y = tx*sin(B) + ty*cos(B);
}
};
struct Point px[1010],dbx[10];
struct Line
{
Point s,e;
Line() {}
Line(Point _s,Point _e)
{
s = _s;
e = _e;
}
//两直线相交求交点
//第一个值为0表示直线重合，为1表示平行，为0表示相交,为2是相交
//只有第一个值为2时，交点才有意义
pair<int,Point> operator &(const Line &b)const
{
Point res = s;
if(sgn((s-e)^(b.s-b.e)) == 0)
{
if(sgn((s-b.e)^(b.s-b.e)) == 0)
return make_pair(0,res);//重合
else return make_pair(1,res);//平行
}
double t = ((s-b.s)^(b.s-b.e))/((s-e)^(b.s-b.e));
res.x += (e.x-s.x)*t;
res.y += (e.y-s.y)*t;
return make_pair(2,res);
}
};
double dist(Point a,Point b)
{
return sqrt(1.0*(a.x-b.x)*(a.x-b.x)+((a.y-b.y))*((a.y-b.y)));
}
double CalcArea(Point a,Point b,Point c,int n)
{
Point p[3];
p[0]=a;
p[1]=b;
p[2]=c;
double res = 0;
for(int i = 0; i < n; i++)
res += (p[i]^p[(i+1)%n])/2;
return fabs(res);
}
bool OnSeg(Point P,Line L)
{
return
sgn((L.s-P)^(L.e-P)) == 0 &&
sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0 &&
sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}
bool ok(Point a,Point b,Point c,Point p)//P点是否在三角形abc内或者在三角形的边上
{
Line ab=Line(a,b);
Line ac=Line(a,c);
Line bc=Line(b,c);
pair<int,Point> j;
j=ab&(ac);
if(j.first!=2)
{
if(!OnSeg(p,ab) && !OnSeg(p,bc) && !OnSeg(p,ac))
return 0;
else
return 1;
}
double spab=CalcArea(p,a,b,3);
double spac=CalcArea(p,a,c,3);
double spbc=CalcArea(p,c,b,3);
double sabc=CalcArea(c,a,b,3);
if(fabs(sabc-(spab+spbc+spac))<=eps)
return 1;
return 0;
}
bool vis[1010];
int main()
{
double x,y;
int t,n,m,i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
scanf("%lf%lf%lf%lf",&dbx[2].x,&dbx[2].y,&dbx[0].x,&dbx[0].y);
for(i=0; i<n; i++)
scanf("%lf%lf",&px[i].x,&px[i].y);
int cont=0;
memset(vis,false,sizeof vis);
for(i=1; i<=m; i++)
{
scanf("%lf%lf",&x,&y);
dbx[i%2].x=x;
dbx[i%2].y=y;
for(j=0; j<n; j++)
{
if(vis[j])
continue;
if(ok(dbx[0],dbx[1],dbx[2],px[j]))
{
cont++;
vis[j]=true;
}
}
}
printf("%d\n",cont);
}
return 0;
}1282: Sphenic Number
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
long long ans[1500005];
long long p[200005], a[200005], tt = 0;
void prime()
{
int i, n=130000, j;
a[1] = 0;
for(i = 2; i <= n; i++)
a[i] = 1;
for(i = 2; i <= n; i++)
if(a[i])
{
p[tt++] = i;
for(j = i; j <= n;j += i)
a[j] = 0;
}
}
int main()
{
prime();
int T, n, t = 0;
for(int i = 0; i < tt; i++)
{
for(int j = i + 1; j < tt; j++)
{
for(int k = j + 1; k < tt; k++)
{
if(p[i] * p[j] * p[k]>539251)
break;
ans[t++] = p[i] * p[j] * p[k];
}
}
}
sort(ans, ans + t);
scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
printf("%lld\n", ans[n - 1]);
}
return 0;
}1294: Coins
#include <cstdio>
#include <map>
#include <cstring>
#define LL long long int
using namespace std;
int main()
{
// freopen("in.cpp","r",stdin);
int len,k;
scanf("%d%d",&len,&k);//长度和K值
char a;
int max = 0;//用来记录最后的结果，初始状态为0
map<LL,int> m;
LL sum = 0;
m[0] = 0;
getchar();
for(int i=1; i<=len; ++i)
{
a = getchar();
if(a == 'O')
++sum;//O，加1
else sum -= k;//R,加-K
map<LL,int>::iterator it;
it = m.find(sum);
if(it != m.end())//出现重复
{
if(max < i-(*it).second)//出现更大长度
max = i-(*it).second;//更新MAX
}
else
m[sum] = i;//未出现重复，保存
}
printf("%d\n",max);
return 0;
}1299: Number Transformation II
#include<iostream>
#include<stdio.h>
#include<cmath>
#include<cstring>
#include<string.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#define pi acos(-1)
#define ll long long
#define oo 2139062143
#define MAXN 200005
using namespace std;
struct node
{
int next;
}h[MAXN];
int n,m,dp[MAXN],p[3000000][2];
int main()
{
int x,i,k;
m=0;
memset(h,0,sizeof(h));
memset(p,0,sizeof(p));
for (i=1;i<=MAXN;i++)
for (x=i*2;x<=MAXN;x+=i)
{
p[++m][0]=i;
p[m][1]=h[x].next;
h[x].next=m;
}
while (~scanf("%d%d",&n,&m))
{
memset(dp,0x7f,sizeof(dp));
dp[n]=0;
for (x=n;x<=m;x++)
{
k=h[x].next;
while (k)
{
i=p[k][0];
if (x+i<=m)
if (dp[x+i]==-1 || dp[x+i]>dp[x]+1)
dp[x+i]=dp[x]+1;
k=p[k][1];
}
}
if (dp[m]==oo) printf("sorry, can not transform\n");
else printf("%d\n",dp[m]);
}
return 0;
}
扫一扫
2023
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
