目录
1603: Scheduling the final examination
1607: Do You Have The Template?
1619: Con + tin / (ued + Frac / tions)
1620: A Cure for the Common Code
1622: Generalized Roman Numerals
1633: Landline Telephone Network
1637: Yet Satisfiability Again!
1658: IQ of XUEXX’s descendants
1784: Internet of Lights and Switches
1835: Pry Sequence Transformation
1850: Grade School Multiplication
1897: The price table of the snack store
1601: War
#include<iostream>
#include <cstdio>
#include <cstring>
#include<stdio.h>
#include<algorithm>
# define N 100005
using namespace std;
int n,m;int father[N];int q;int ans;
int a[N],b[N],vis[N],k[N];
void init(int n)
{
for(int i=0;i<=n;i++)
{
father[i]=i;
}
ans=n;
}
int find(int x)
{
if(x!=father[x])
father[x]=find(father[x]);
return father[x];
}
void Union(int a,int b)
{
int fa=find(a);int fb=find(b);
if(fa!=fb)
{
father[fa]=fb;
ans--;
}
}
int main()
{
while(scanf("%d%d",&n,&m)>0)
{
init(n);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a[i],&b[i]);vis[i]=1;
}
scanf("%d",&q);
for(int i=1;i<=q;i++)
{
scanf("%d",&k[i]);vis[k[i]]=0;
}
for(int i=1;i<=m;i++)
{
if(vis[i]) Union(a[i],b[i]);
}
for(int i=q;i>=1;i--)
{
int tt=k[i];
k[i]=ans;
Union(a[tt],b[tt]);
}
for(int i=1;i<q;i++)
{
printf("%d ",k[i]);
}
printf("%d\n",k[q]);
}
return 0;
}1602: Needle Throwing Game
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double PI = acos(-1.0);
#define Len 200005
#define mod 19999997
const int INF = 0x3f3f3f3f;
#define exp 1e-8
int main()
{
double L,D;
double P;
w(~scanf("%lf%lf",&D,&L))
{
if(L<D) P=2*L/(PI*D);
else P=1+(2.0/PI)*((L*1.0/D)*(1-sqrt((1-(D*D)/(L*L))))-asin(D*1.0/L));
P=P*10000;
printf("%d\n",(int)P);
}
return 0;
}1603: Scheduling the final examination
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
#define REP(x, y) for(int x = 0; x < y; x++)
#define DWN(x, y) for(int x = y-1; x > -1; x--)
struct Exam
{
int s,t,a,d;
int add()
{
if(100-s>a) return a;
else return 100-s;
}
}ex[60];
int timer[750];
int main()
{
// freopen("D.in", "r", stdin);
int n;
while(scanf("%d",&n)!=EOF)
{
int mx=-1;
memset(timer,0,sizeof timer);
for(int i=0;i<n;i++)
{
scanf("%d%d%d%d",&ex[i].s,&ex[i].t,&ex[i].a,&ex[i].d);
mx=max(mx,ex[i].t);
int t=ex[i].t;
while(t>0&&ex[i].s<60&&ex[i].a>0)
{
if(timer[t]==0)
{
ex[i].s+=ex[i].add();
ex[i].a-=ex[i].d;
timer[t]=1;
}
t--;
}
}
for(int i=720;i>0;i--)
{
if(!timer[i])
{
int m=-1;
for(int j=0;j<n;j++)
{
if(ex[j].t>=i&&(m==-1||ex[m].add()<ex[j].add()))
m=j;
}
if(m!=-1&&ex[m].a>0)
{
ex[m].s+=ex[m].add();
ex[m].a-=ex[m].d;
}
}
}
int ans=0;
int flag=1;
for(int i=0;i<n;i++)
{
if(ex[i].s>=60)
ans+=ex[i].s;
else
{
flag=0; break;
}
}
if(flag)
printf("%d\n",ans);
else puts("you are unlucky");
}
return 0;
}1604: SunnyPig
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 200005
#define mod 19999997
const int INF = 0x3f3f3f3f;
#define exp 1e-8
struct node
{
int x,y,door;
};
int mat[1000][1000],n,m,t,vis[1000][1000],sx,sy;
char str[1005];
int to[5][2]= {0,0,0,1,1,0,0,-1,-1,0};
bool outdoor(int x,int y)
{
if(x==0||y==0||x==n-1||y==m-1)
return true;
return false;
}
bool check(int x,int y)
{
if(x<0||y<0||x==n||y==m)
return true;
if(mat[x][y]==-1||vis[x][y])
return true;
return false;
}
void bfs()
{
queue<node> Q;
node a,next;
int i,j;
a.x = sx;
a.y = sy;
a.door = 0;
vis[sx][sy] = 1;
Q.push(a);
while(!Q.empty())
{
a = Q.front();
Q.pop();
if(outdoor(a.x,a.y)&&mat[a.x][a.y]>0)
{
printf("%d\n",a.door);
return ;
}
up(i,1,4)
{
next = a;
next.x+=to[i][0];
next.y+=to[i][1];
if(check(next.x,next.y)) continue;
if(mat[next.x][next.y]>0 && mat[next.x][next.y]!=i) continue;
if(mat[next.x][next.y]>0)
{
next.door++;
if(outdoor(next.x,next.y))
{
printf("%d\n",next.door);
return ;
}
}
vis[next.x][next.y] = 1;
Q.push(next);
}
}
printf("-1\n");
}
int main()
{
int i,j,k;
scanf("%d",&t);
w(t--)
{
scanf("%d%d\n",&n,&m);
n=2*n+1;
m=2*m+1;
mem(mat,-1);
up(i,0,n-1)
{
gets(str);
up(j,0,m-1)
{
if(str[j]==' '||str[j]=='*')
mat[i][j]=0;
else if(str[j]=='-'||str[j]=='|')
mat[i][j]=-1;
else if(str[j]=='E')
mat[i][j]=1;
else if(str[j]=='S')
mat[i][j]=2;
else if(str[j]=='W')
mat[i][j]=3;
else if(str[j]=='N')
mat[i][j]=4;
else if(str[j]=='O')
{
sx = i;
sy = j;
mat[i][j]=0;
}
}
}
bfs();
}
return 0;
} 1605: Target Sudoku
#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>
#define MEM(a,x) memset(a,x,sizeof a)
#define eps 1e-8
#define MOD 10009
#define INF 99999999
#define ll __int64
#define bug cout<<"here"<<endl
#define fread freopen("ceshi.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)
using namespace std;
const int N=9;
const int MAXN=N*N*N+10;
const int MAXM=N*N*4+10;
const int maxnode=MAXN*4+MAXM+10;
int ch[MAXN];
int mx;
int mul[9][9]={6,6,6,6,6,6,6,6,6,
6,7,7,7,7,7,7,7,6,
6,7,8,8,8,8,8,7,6,
6,7,8,9,9,9,8,7,6,
6,7,8,9,10,9,8,7,6,
6,7,8,9,9,9,8,7,6,
6,7,8,8,8,8,8,7,6,
6,7,7,7,7,7,7,7,6,
6,6,6,6,6,6,6,6,6,
};
struct DLX
{
int n,m,size;
int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
int H[MAXN], S[MAXM];
int ansd, ans[MAXN];
void init(int _n,int _m)
{
n = _n;
m = _m;
for(int i = 0;i <= m;i++)
{
S[i] = 0;
U[i] = D[i] = i;
L[i] = i-1;
R[i] = i+1;
}
R[m] = 0; L[0] = m;
size = m;
for(int i = 1;i <= n;i++)
H[i] = -1;
}
void Link(int r,int c)
{
++S[Col[++size]=c];
Row[size] = r;
D[size] = D[c];
U[D[c]] = size;
U[size] = c;
D[c] = size;
if(H[r] < 0)H[r] = L[size] = R[size] = size;
else
{
R[size] = R[H[r]];
L[R[H[r]]] = size;
L[size] = H[r];
R[H[r]] = size;
}
}
void remove(int c)
{
L[R[c]] = L[c]; R[L[c]] = R[c];
for(int i = D[c];i != c;i = D[i])
for(int j = R[i];j != i;j = R[j])
{
U[D[j]] = U[j];
D[U[j]] = D[j];
--S[Col[j]];
}
}
void resume(int c)
{
for(int i = U[c];i != c;i = U[i])
for(int j = L[i];j != i;j = L[j])
++S[Col[U[D[j]]=D[U[j]]=j]];
L[R[c]] = R[L[c]] = c;
}
//d为递归深度
bool Dance(int d)
{
if(R[0] == 0)
{
// cout<<"d "<<d<<endl;
for(int i=0;i<d;i++) ch[(ans[i]-1)/9]=(ans[i]-1)%9+1;
int sum=0;
for(int i=0;i<N*N;i++)
{
int nn=i/N;
int mm=i%N;
// cout<<ch[i];
// if(mm==8)
// puts("");
sum+=ch[i]*mul[nn][mm];//根据每个位置的权 求出和
}
mx=max(mx,sum);
// cout<<mx<<endl;
return 1;
}
int flag=0;
int c = R[0];
for(int i = R[0];i != 0;i = R[i])
if(S[i] < S[c])
c = i;
remove(c);
for(int i = D[c];i != c;i = D[i])
{
ans[d] = Row[i];
for(int j = R[i]; j != i;j = R[j])remove(Col[j]);
if(Dance(d+1)) flag=1;//这里不能直接返回1 需要继续计算 求出所有情况中的最大值
for(int j = L[i]; j != i;j = L[j])resume(Col[j]);
}
resume(c);
return flag;
}
}dlx;
void place(int &r,int &c1,int &c2,int &c3,int &c4,int i,int j,int k)
{
r=(i*N+j)*N+k; c1=i*N+j+1; c2=N*N+i*N+k;
c3=N*N*2+j*N+k; c4=N*N*3+((i/3)*3+(j/3))*N+k;
}
int main()
{
// fread;
int tc;
scanf("%d",&tc);
while(tc--)
{
mx=-1;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
scanf("%d",&ch[i*N+j]);
dlx.init(N*N*N,N*N*4);
int r,c1,c2,c3,c4;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
for(int k=1;k<=N;k++)
if(ch[i*N+j]==0||ch[i*N+j]==k)
{
place(r,c1,c2,c3,c4,i,j,k);
dlx.Link(r,c1);
dlx.Link(r,c2);
dlx.Link(r,c3);
dlx.Link(r,c4);
}
bool flag=dlx.Dance(0);
if(!flag)
puts("-1");
else
printf("%d\n",mx);
}
return 0;
}1607: Do You Have The Template?
#include<stdio.h>
#include<string.h>
#include<vector>
const int N=10015;
using namespace std;
int head[N], to[N << 1], next1[N << 1], tot;
int top[N]; //top[v]=u表示点v,u在一个链中，且u是这个链深度最小的点（即顶端）
int fath[N]; //记录父节点
int deep[N]; //每个点在树上的深度
int num[N]; //每棵子树的节点个数
int son[N]; //选的重边子节点
int p[N]; //树上每个点在线段树中所对应的点
int pos;
void addEdge(const int& u, const int& v) {
to[tot] = v, next1[tot] = head[u], head[u] = tot++;
}
void addUndirEdge(const int& u, const int& v) {
addEdge(u, v), addEdge(v, u);
}
void init(int n)
{
pos=0; tot=0;
memset(son,-1,sizeof(son));
memset(head,-1,sizeof(head));
}
void dfs1(int u,int pre,int d)
{
deep[u]=d; fath[u]=pre; num[u]=1;
for (int i = head[u]; i != -1; i = next1[i]) {
int v = to[i];
if(v==pre)continue;
dfs1(v,u,d+1);
num[u]+=num[v];
if(son[u]==-1||num[v]>num[son[u]])
son[u]=v;
}
}
void getpos(int u,int root)
{
top[u]=root;
p[u]=pos++;
if(son[u]==-1)
return ;
getpos(son[u],root);
for (int i = head[u]; i != -1; i = next1[i]) {
int v = to[i];
if(son[u]!=v&&v!=fath[u])
getpos(v,v);
}
}
//线段树
struct tree
{
int sum,maxv,toc,addc;
}root[N*4];
int val[N];
int MAX(int a,int b)
{
return a>b?a:b;
}
void build(int l,int r,int k)
{
int mid=(l+r)/2;
root[k].addc=0;
root[k].toc=0;
if(l==r){
root[k].sum=root[k].maxv=val[l]; return ;
}
build(l,mid,k<<1);
build(mid+1,r,k<<1|1);
root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
void upson(int k,int l,int r)
{
int mid=(l+r)/2;
if(root[k].toc)
{
root[k<<1].sum=(mid-l+1)*root[k].toc;
root[k<<1].maxv=root[k].toc;
root[k<<1].toc=root[k].toc;
root[k<<1].addc=0;
root[k<<1|1].sum=(r-mid)*root[k].toc;
root[k<<1|1].maxv=root[k].toc;
root[k<<1|1].toc=root[k].toc;
root[k<<1|1].addc=0;
root[k].toc=0;
}
if(root[k].addc)
{
root[k<<1].sum+=(mid-l+1)*root[k].addc;
root[k<<1].maxv+=root[k].addc;
root[k<<1].addc+=root[k].addc;
root[k<<1|1].sum+=(r-mid)*root[k].addc;
root[k<<1|1].maxv+=root[k].addc;
root[k<<1|1].addc+=root[k].addc;
root[k].addc=0;
}
}
void updata1(int l,int r,int k,const int L,const int R,int c)
{
if(L<=l&&r<=R)
{
root[k].sum=(r-l+1)*c; root[k].maxv=c;
root[k].toc=c; root[k].addc=0;
return ;
}
int mid=(l+r)/2;
upson(k,l,r);
if(L<=mid)
updata1(l,mid,k<<1,L,R,c);
if(mid<R)
updata1(mid+1,r,k<<1|1,L,R,c);
root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
void updata2(int l,int r,int k, int L, int R,int c)
{
if(L<=l&&r<=R)
{
root[k].sum+=(r-l+1)*c; root[k].maxv+=c;
root[k].addc+=c;
return ;
}
int mid=(l+r)/2;
upson(k,l,r);
if(L<=mid)
updata2(l,mid,k<<1,L,R,c);
if(mid<R)
updata2(mid+1,r,k<<1|1,L,R,c);
root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
int sum,maxv;
void query(int l,int r,int k,int L,int R)
{
if(L<=l&&r<=R)
{
sum+=root[k].sum;
maxv=MAX(maxv,root[k].maxv);
return ;
}
int mid=(l+r)/2;
upson(k,l,r);
if(L<=mid)
query(l,mid,k<<1,L,R);
if(mid<R)
query(mid+1,r,k<<1|1,L,R);
}
void swp(int &a,int &b)
{
int tt;
tt=a; a=b; b=tt;
}
void Operat0(int u,int v)
{
int f1=top[u], f2=top[v];
sum=0; maxv=0;
while(f1!=f2)
{
if(deep[f1]<deep[f2])
{
swp(f1,f2); swp(u,v);
}
query(1,pos,1,p[f1],p[u]);
u=fath[f1]; f1=top[u];
}
if(u==v) return ;
if(deep[u]>deep[v])swp(u,v);
query(1,pos,1,p[son[u]],p[v]);
}
void Operat1(int u,int v,int c)
{
int f1=top[u], f2=top[v];
while(f1!=f2)
{
if(deep[f1]<deep[f2])
{
swp(f1,f2); swp(u,v);
}
updata1(1,pos,1,p[f1],p[u],c);
u=fath[f1]; f1=top[u];
}
if(u==v) return ;
if(deep[u]>deep[v])swp(u,v);
updata1(1,pos,1,p[son[u]],p[v],c);
}
void Operat2(int u,int v,int c)
{
int f1=top[u], f2=top[v];
while(f1!=f2)
{
if(deep[f1]<deep[f2])
{
swp(f1,f2); swp(u,v);
}
updata2(1,pos,1,p[f1],p[u],c);
u=fath[f1]; f1=top[u];
}
if(u==v) return ;
if(deep[u]>deep[v])swp(u,v);
updata2(1,pos,1,p[son[u]],p[v],c);
}
struct EDG
{
int u,v,c;
}edg[N];
int main()
{
int n,q,op,a,b;
while(scanf("%d",&n)!=EOF)
{
init(n);
for(int i=1;i<n;i++)
{
scanf("%d%d%d",&edg[i].u,&edg[i].v,&edg[i].c);
addUndirEdge(edg[i].u, edg[i].v);
}
dfs1(1,1,1);
getpos(1,1);
pos=n;
for(int i=1;i<n;i++)
{
if(deep[edg[i].u]>deep[edg[i].v])
edg[i].v=edg[i].u;
val[p[edg[i].v]]=edg[i].c;
}
build(1,pos,1);
scanf("%d",&q);
while(q--)
{
scanf("%d%d%d",&op,&a,&b);
if(op==0)
{
Operat0(a,b);
printf("%d %d\n",maxv,sum);
}
else if(op==1)
updata1(1,pos,1,p[edg[a].v],p[edg[a].v],b);
else
{
int tt,c;
scanf("%d%d",&tt,&c);
if(tt==0)
Operat1(a,b,c);
else
Operat2(a,b,c);
}
}
}
}1608: Particle Collider
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 1000005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int wa[N],wb[N],wsf[N],wv[N],sa[N];
int rank1[N],height[N],s[N],a[N];
//sa:字典序中排第i位的起始位置在str中第sa[i]
//rank:就是str第i个位置的后缀是在字典序排第几
//height：字典序排i和i-1的后缀的最长公共前缀
int cmp(int *r,int a,int b,int k)
{
return r[a]==r[b]&&r[a+k]==r[b+k];
}
void getsa(int *r,int *sa,int n,int m)//n要包含末尾添加的0
{
int i,j,p,*x=wa,*y=wb,*t;
for(i=0; i<m; i++) wsf[i]=0;
for(i=0; i<n; i++) wsf[x[i]=r[i]]++;
for(i=1; i<m; i++) wsf[i]+=wsf[i-1];
for(i=n-1; i>=0; i--) sa[--wsf[x[i]]]=i;
p=1;
j=1;
for(; p<n; j*=2,m=p)
{
for(p=0,i=n-j; i<n; i++) y[p++]=i;
for(i=0; i<n; i++) if(sa[i]>=j) y[p++]=sa[i]-j;
for(i=0; i<n; i++) wv[i]=x[y[i]];
for(i=0; i<m; i++) wsf[i]=0;
for(i=0; i<n; i++) wsf[wv[i]]++;
for(i=1; i<m; i++) wsf[i]+=wsf[i-1];
for(i=n-1; i>=0; i--) sa[--wsf[wv[i]]]=y[i];
t=x;
x=y;
y=t;
x[sa[0]]=0;
for(p=1,i=1; i<n; i++)
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)? p-1:p++;
}
}
void getheight(int *r,int n)//n不保存最后的0
{
int i,j,k=0;
for(i=1; i<=n; i++) rank1[sa[i]]=i;
for(i=0; i<n; i++)
{
if(k)
k--;
else
k=0;
j=sa[rank1[i]-1];
while(r[i+k]==r[j+k])
k++;
height[rank1[i]]=k;
}
}
char str[N];
int id[N];
map<string,int> mat,ans;
map<string,int>::iterator it;
int check(int x)//统计该状态包括几个串
{
int i,cnt = 0;
for(i = 1; i<=10; i++)
if((1<<i)&x)
cnt++;
return cnt;
}
int main()
{
int n,i,j,k,len;
while(~scanf("%d",&k))
{
MEM(id,0);
n = 0;
int p = 200;
for(i = 1; i<=k; i++)
{
scanf("%s",str);
len = strlen(str);
for(j = 0; j<len; j++)
{
id[n] = i;
s[n++] = str[j];
}
s[n++] = p++;
for(j = len-1; j>=0; j--)
s[n++] = str[j];
s[n++] = p++;
}
if(k == 1)
{
printf("%s\n",str);
continue;
}
getsa(s,sa,n,p);
getheight(s,n);
int l = 1,r = 1000;
ans.clear();
while(l<=r)
{
int mid = (l+r)/2;
i = 0;
mat.clear();
while(i<n)
{
if(height[i]>=mid)
{
int tem = 1<<id[sa[i-1]];
len = 2000;
while(height[i]>=mid && i<n)//二进制记录串
{
tem |= (1<<id[sa[i]]);
len = min(len,height[i]);
i++;
}
if(tem!=1)
{
char s1[1005],s2[1005];
for(j = len-1; j>=0; j--)
{
s1[len-1-j] = s[sa[i-1]+j];
s2[j] = s[sa[i-1]+j];
}
s1[len] = s2[len] = '\0';
if(mat.find(string(s1)) != mat.end())
mat[string(s1)] |= tem;
else
mat[string(s2)] = tem;
}
}
i++;
}
int flag = 0;
for(it = mat.begin(); it!=mat.end(); it++)
{
if(check(it->second) >= k/2+1)
{
if(flag==0)
{
ans.clear();
flag = 1;
}
ans.insert(*it);
}
}
if(flag==0) r = mid-1;
else l = mid+1;
}
if(ans.size()==0)
printf("NONE\n");
else
{
for(it = ans.begin(); it!=ans.end(); it++)
{
printf("%s\n",it->first.c_str());
}
}
}
return 0;
}1611: Concatenation
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define N 1000005
#define mod 19999997
#define INF 0x3f3f3f3f
#define exp 1e-8
int t,n;
char s[15][55],s1[15][55];
int dp[1<<13][55],len[15],cnt,flag;
int hsh[15][15];//hsh[i][j]表示j串接在i串后面，除掉合并的部分，实际上j串只加上去了hsh[i][j]的长度
int main()
{
int i,j,k,x,y;
cin>>t;
w(t--)
{
cin>>n;
up(i,0,n-1)
{
scanf("%s",s[i]);
}
cnt = 0;
up(i,0,n-1)
{
flag = 0;
up(j,0,n-1)
{
if(strstr(s[j],s[i]) && strcmp(s[i],s[j])) flag = 1;
}
if(!flag)
strcpy(s1[cnt++],s[i]);
}
n = 0;
up(i,0,cnt-1)
{
flag = 0;
up(j,0,i-1)
{
if(!strcmp(s1[i],s1[j])) flag = 1;
}
if(!flag)
strcpy(s[n++],s1[i]);
}
up(i,0,n-1)
{
len[i]=strlen(s[i]);
}
mem(hsh,0);
up(i,0,n-1)
{
up(j,0,n-1)
{
hsh[i][j] = len[j];
int pos = -1;
down(k,len[i]-1,1)
{
flag = 1;
up(x,k,len[i]-1)
{
if(s[i][x]!=s[j][x-k]) flag = 0;
}
if(flag) pos = k;
}
if(pos!=-1) hsh[i][j] = len[j]-len[i]+pos;
}
}
mem(dp,INF);
int size = (1<<n)-1,pre=0,now;
up(i,1,size)
{
up(j,0,n-1)
{
if(i&(1<<j))
{
pre = (i^(1<<j));
if(pre==0) dp[i][j] = len[j];
up(k,0,n-1)
{
if(j!=k && (i&(1<<k))==0)
{
now=(i|(1<<k));
dp[now][k]=min(dp[now][k],dp[i][j]+hsh[j][k]);
}
}
}
}
}
int minn = INF;
up(i,0,n-1)
minn = min(minn,dp[size][i]);
printf("%d\n",minn);
}
return 0;
}1612: Destroy Tunnels
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <set>
#include <map>
#define lson o<<1, l, m
#define rson o<<1|1, m+1, r
#define PII pair<int, int>
#define ALL(x) x.begin(),x.end()
#define mem(a) memset(a,0,sizeof(a))
typedef long long ll;
const double pi = acos(-1.0);
const int MAX = 0x3f3f3f3f;
const ll mod = 1000000007ll;
const int N = 1005;
using namespace std;
int T, n, x;
int a[N][N], scc[N], cnt, v[N];
vector <int> G[N], G2[N], S;
void dfs1(int u) {
if(v[u]) return;
v[u] = 1;
for(int i = 0; i < G[u].size(); i++) {
dfs1(G[u][i]);
}
S.push_back(u);
}
void dfs2(int u) {
if(scc[u]) return;
scc[u] = cnt;
for(int i = 0; i < G2[u].size(); i++) {
dfs2(G2[u][i]);
}
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
cin >> T;
while(T--) {
cin >> n;
cnt = 0;
mem(scc);
mem(v);
for(int i = 0; i < n; i++) {
G2[i].clear();
G[i].clear();
}
S.clear();
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
scanf("%d", &x);
if(x) {
G[i].push_back(j);
G2[j].push_back(i);
}
}
}
for(int i = 0; i < n; i++) {
dfs1(i);
}
for(int i = n-1; i >= 0; i--) {
if(!scc[S[i]]) {
cnt++;
dfs2(S[i]);
}
}
puts(cnt == 1 ? "not exists" : "exists");
}
return 0;
}
1613: Elephants
#include <stdio.h>
#include <string.h>
int t,n,m;
int dp[1010],A[21][51],C[21][51],num[21];
int max(int x,int y)
{
return x > y?x:y;
}
int main()
{
// freopen("in.txt","r",stdin);
scanf("%d",&t);
while(t--)
{
memset(dp, 0,sizeof dp);
scanf("%d%d",&n,&m);
for (int i = 1;i <= n;i++)
{
scanf("%d",&num[i]);
for (int j = 0;j < num[i];j++)
scanf("%d%d",&A[i][j],&C[i][j]);
}
for (int i = 1;i <= n;i++)
{
for (int j = m;j >= 0;--j)
{
for (int k = 0;k < num[i];++k)
if (j >= A[i][k]) dp[j] = max(dp[j],dp[j - A[i][k]] + C[i][k]);
}
}
printf("%d\n",dp[m]);
}
return 0;
}1614: First Blood
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define N 50005
#define mod 19999997
const int INF = 0x3f3f3f3f;
#define exp 1e-8
struct node
{
int x,y,r;
}a[105];
bool vis[105][105];
int main()
{
int i,j,k,t,n;
cin >> t;
w(t--)
{
cin >> n;
up(i,0,n-1)
scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].r);
mem(vis,false);
up(i,0,n-1)
{
up(j,0,n-1)
{
int t1 = (a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y);
int t2 = (a[i].r+a[j].r)*(a[i].r+a[j].r);
if(t1>t2) vis[i][j]=vis[j][i] = true;
}
}
int ans = 0,flag;
up(i,0,n-1)
{
flag = 0;
up(j,0,n-1)
{
if(i!=j && !vis[i][j]) flag = 1;
}
if(!flag)
ans++;
}
cout<<ans<<endl;
}
return 0;
} 1615: Garden
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define N 1000005
#define mod 19999997
#define INF 0x3f3f3f3f
#define exp 1e-8
int main()
{
int T;
int x,y,z;
scanf("%d",&T);
w(T--)
{
int a,b,c;
scanf("%d%d%d",&x,&y,&z);
a=2*x*y*z/(y*z+x*y-z*x);
b=2*x*y*z/(x*z+y*z-x*y);
c=2*x*y*z/(x*y+x*z-y*z);
printf("%d %d %d\n",a,b,c);
}
return 0;
}1616: Heaps
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define N 1005
#define mod 19999997
#define INF 0x3f3f3f3f
#define exp 1e-8
LL dp[N][N],vec[50000],sum[N];
int s[N],a[N],t,n,m,tot,vis[N][N];
LL col(LL x)
{
LL ans = a[0];
int i,j;
up(i,1,m)
{
LL tem = 1;
up(j,1,i) tem*=x;
ans+=tem*a[i];
}
return ans;
}
int main()
{
int i,j,k;
scanf("%d",&t);
w(t--)
{
scanf("%d",&n);
mem(sum,0);
mem(dp,0);
tot=0;
up(i,1,n)
{
scanf("%d",&s[i]);
sum[i] = sum[i-1]+s[i];
tot+=s[i];
}
scanf("%d",&m);
up(i,0,m)
{
scanf("%d",&a[i]);
}
up(i,1,tot)
{
vec[i]=col((LL)i);
}
up(i,1,n) vis[i][i] = i;
vis[0][1] = 1;
int len;
up(len,2,n)
{
up(i,1,n-len+1)
{
j = i+len-1;
dp[i][j] = 1LL<<60;
up(k,vis[i][j-1],vis[i+1][j])
{
LL tem = dp[i][k]+dp[k+1][j]+vec[sum[j]-sum[i-1]];
if(tem<dp[i][j])
{
dp[i][j] = tem;
vis[i][j] = k; //记录合并点
}
}
}
}
printf("%lld\n",dp[1][n]);
}
return 0;
} 1617: Itself is Itself
#include<stdio.h>
#include<vector>
#include<string.h>
using namespace std;
#define modd 1000000007
const int N= 10005;
int n,c[N];
int dfn[N],low[N],Stack[N],flag[N],vist[N],num[N],top,deep,tn;
vector<int>mapt1[N];
void init()
{
for(int i=0;i<=n;i++)
{
mapt1[i].clear();
dfn[i]=0;
num[i]=0;
vist[i]=0;
}
tn=top=deep=0;
}
int tt;
void tarjan(int u)
{
vist[u]=tt;
deep++;
dfn[u]=low[u]=deep;
Stack[++top]=u;
int len=mapt1[u].size();
for(int i=0;i<len;i++)
{
int v=mapt1[u][i];
if(vist[v]==0)
{
tarjan(v);
if(low[u]>low[v])
low[u]=low[v];
}
else if(vist[v]==tt&&low[u]>dfn[v])//注意vist[v]==tt
low[u]=dfn[v];
}
if(low[u]==dfn[u])
{
tn++;
while(u!=Stack[top])
{
flag[Stack[top]]=tn; num[tn]++;top--; //printf("%d ",Stack[top]);
}
flag[Stack[top]]=tn; num[tn]++; top--;
}
}
int out[N];
int rebuilMap()//用强连通缩点，重新反向建图
{
tt=0;
for(int i=0;i<n;i++)
if(vist[i]==0)
{
tt++;
tarjan(i);
}
memset(out,0,sizeof(out));
//缩点后的图无 有向环
for(int i=0;i<n;i++)
{
int u=flag[i];
for(int j=0;j<mapt1[i].size();j++)
{
int v=flag[mapt1[i][j]];
if(u==v)
continue;
out[u]++;
}
}
int number=0;
for(int i=1;i<=tn;i++)
if(out[i]==0)
number++;
return number;
}
int main()
{
int T,m;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&m);
for(int i=0;i<=m;i++){
scanf("%d",&c[i]);
c[i]%=n;
}
init();
for(int i=0;i<n;i++)
{
int ansa=c[0],x=i;
for(int j=1;j<=m;j++){
ansa=(ansa+c[j]*x)%n;
x=(x*i)%n;
}
if(i!=ansa)
mapt1[i].push_back(ansa);
}
int number=rebuilMap();
long long ans = 1;
for(int i=1;i<=number;i++)
ans=(ans*2)%1000000007;
printf("%lld\n",ans);
}
return 0;
}1619: Con + tin / (ued + Frac / tions)
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#define esp 1e-12
#define LL long long
#define gcd(a,b) __gcd(a,b)
using namespace std;
LL a[25];
void Print(LL a,LL b)
{
LL gg = gcd(a, b);
a /= gg;
b /= gg;
if (b < 0)
{
a *= -1;
b *= -1;
}
LL tmp = (a % b + b) % b;
LL a0 = (a - tmp) / b;
printf("%lld", a0);
a=tmp;
swap(a,b);
while(b)
{
tmp=a/b;
printf(" %lld",tmp);
a=a%b;
swap(a,b);
}
printf("\n");
}
int main()
{
int Ca=1;
int n1,n2;
LL fm1,fm2,fm3,fz1,fz2,fz3;
while(scanf("%d%d",&n1,&n2),(n1!=0&&n2!=0))
{
for(int i=0; i<n1; i++)
{
scanf("%lld",&a[i]);
}
if(n1==1)
{
fm1=0;
fz1=a[0];
}
else
{
fm1=a[n1-1];
fz1=1;
for(int i=n1-2; i>0; i--)
{
LL tmp=fm1;
fm1=fz1+a[i]*fm1;
fz1=tmp;
}
fz1=fz1+a[0]*fm1;
}
for(int i=0; i<n2; i++)
{
scanf("%lld",&a[i]);
}
if(n2==1)
{
fm2=0;
fz2=a[0];
}
else
{
fm2=a[n2-1];
fz2=1;
for(int i=n2-2; i>0; i--)
{
LL tmp=fm2;
fm2=fz2+a[i]*fm2;
fz2=tmp;
}
fz2=fz2+a[0]*fm2;
}
printf("Case %d:\n",Ca++);
if(fm1==0||fm2==0)
{
if(fm1==0&&fm2!=0)
{
Print(fz1*fm2+fz2,fm2);
}
if(fm1!=0&&fm2==0)
{
Print(fz2*fm1+fz1,fm1);
}
if(fm1==0&&fm2==0)
printf("%lld\n",fz1+fz2);
}
else
{
Print(fz1*fm2+fz2*fm1,fm1*fm2);
}
if(fm1==0||fm2==0)
{
if(fm1==0&&fm2!=0)
{
Print(fz1*fm2-fz2,fm2);
}
if(fm1!=0&&fm2==0)
{
Print(fz1-fz2*fm1,fm1);
}
if(fm1==0&&fm2==0)
printf("%lld\n",fz1-fz2);
}
else
{
Print(fz1*fm2-fz2*fm1,fm1*fm2);
}
if(fm1==0||fm2==0)
{
if(fm1==0&&fm2!=0)
{
Print(fz1*fz2,fm2);
}
if(fm1!=0&&fm2==0)
{
Print(fz1*fz2,fm1);
}
if(fm1==0&&fm2==0)
printf("%lld\n",fz1*fz2);
}
else
{
Print(fz1*fz2,fm1*fm2);
}
if(fm1==0||fm2==0)
{
if(fm1==0&&fm2!=0) Print(fz1*fm2,fz2);
if(fm1!=0&&fm2==0)Print(fz1,fm1*fz2);
if(fm1==0&&fm2==0)Print(fz1,fz2);
}
else
{
Print(fz1*fm2,fm1*fz2);
}
}
return 0;
}1620: A Cure for the Common Code
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define LL long long
#define N 505
#define MOD 19999997
#define INF 0x3f3f3f3f
#define EXP 1e-8
int dp[N][N],next1[N],cas = 1;
char s[N];
int kmp(char *s,int len)//kmp求循环节的长度
{
next1[0] = next1[1] = 0;
int i;
UP(i,1,len-1)
{
int j = next1[i];
W((j&&s[i]!=s[j]))
{
j = next1[j];
}
if(s[i]==s[j])
next1[i+1]=j+1;
else
next1[i+1]=0;
}
return len-next1[len];
}
int getbit(int x)
{
int cnt = 0;
W(x)
{
x/=10;
cnt++;
}
return cnt;
}
void DP()
{
int n = strlen(s+1);
int len,l,r,k,i;
UP(i,1,n)
dp[i][i]=1;
UP(len,2,n)//区间dp求解最优值
{
for(l = 1; l+len-1<=n; l++)
{
r = l+len-1;
dp[l][r]=dp[l][l]+dp[l+1][r];
UP(k,l+1,r-1)
{
dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]);
}
int t = kmp(s+l,len);
if(len%t==0)//现在枚举的串是一个周期循环
{
int tem = dp[l][l+t-1];
if(t>1) tem+=2;//因为不是一个字符的话要加括号
tem+=getbit(len/t);//周期数
dp[l][r]=min(tem,dp[l][r]);
}
}
}
printf("Case %d: %d\n",cas++,dp[1][n]);
}
int main()
{
W(~scanf("%s",s+1))
{
if(s[1]=='0')
break;
DP();
}
return 0;
}1622: Generalized Roman Numerals
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 25
#define MOD 19999997
#define INF 0x3f3f3f3f
#define EXP 1e-8
char s[100];
int cas = 1;
inline int getit(char c)
{
if(c=='I') return 1;
if(c=='V') return 5;
if(c=='X') return 10;
if(c=='L') return 50;
return 100;
}
struct node
{
void init()
{
MEM(hsh,-1);
st = 0;
}
void set(int x)
{
if(hsh[x]!=-1) return;
hsh[x] = st;//记录路径
st = x;//记录尾指针
}
int st;
int hsh[5005];
} dp[55][55];
inline void solve(node& a,node& b,node& c)//枚举所有的情况，这里使用地址符号的时间比不使用要优化很多，原因我也不是很清楚了
{
int i,j;
for(i = a.st; i>0; i=a.hsh[i])
{
for(j = b.st; j>0; j=b.hsh[j])
{
if(i>=j)
c.set(i+j);
else
c.set(j-i);
}
}
}
vector<int> ans;
int main()
{
int i,j,k,len;
W(~scanf("%s",s))
{
if(s[0]=='0')
break;
printf("Case %d:",cas++);
int n = strlen(s);
UP(i,0,n-1)
{
dp[i][1].init();
dp[i][1].set(getit(s[i]));
}
UP(len,2,n)
{
UP(i,0,n-len)
{
dp[i][len].init();
UP(k,1,len-1)
{
solve(dp[i][k],dp[i+k][len-k],dp[i][len]);
}
}
}
ans.clear();
for(i = dp[0][n].st; i!=0; i=dp[0][n].hsh[i])
ans.push_back(i);
sort(ans.begin(),ans.end());
len = ans.size();
UP(i,0,len-1)
printf(" %d",ans[i]);
printf("\n");
}
return 0;
}1623: Inspectors
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 222;
const int M = 11111;
const int INF = 1e9;
struct edge{
int to,next;
int cap,flow,cost;
}e[M << 1];
int head[N],sz,res;
bool inq[N];
int p[N],d[N],a[N];
void addedge(int u,int v,int cap,int cost){
e[sz].to = v;e[sz].next = head[u];
e[sz].cap = cap;e[sz].flow = 0;e[sz].cost = cost;
head[u] = sz ++;
e[sz].to = u;e[sz].next = head[v];
e[sz].cap = 0;e[sz].flow = 0;e[sz].cost = -cost;
head[v] = sz ++;
}
void init(){
memset(head,-1,sizeof(head));
sz = 0;
}
int SPFA(int s,int t){
queue<int> Q;
memset(inq,0,sizeof(inq));
for(int i = 1 ; i <= t ; i ++) d[i] = INF;
inq[s] = 1;d[s] = 0;p[s] = -1;
a[s] = INF;
Q.push(s);
while(!Q.empty()){
int u = Q.front();Q.pop();
inq[u] = 0;
for(int i = head[u] ; i != -1 ; i = e[i].next){
int v = e[i].to;
if(e[i].cap - e[i].flow > 0 && e[i].cost + d[u] < d[v]){
d[v] = d[u] + e[i].cost;
a[v] = min(e[i].cap - e[i].flow,a[u]);
p[v] = i;
if(!inq[v]){
inq[v] = 1;
Q.push(v);
}
}
}
}
int u = t;
if(d[t] == INF) return 0;
res += d[t] * a[t];
while(u != s){
e[ p[u] ].flow += a[t];
e[ p[u] ^ 1 ].flow -= a[t];
u = e[ p[u] ^ 1 ].to;
}
return 1;
}
int txt = 1;
void MCMF(int s,int t){
res = 0;
while(SPFA(s,t));
printf("Case %d: %d\n",txt ++,res);
}
void solve(){
init();
int s,t,c,n;
scanf("%d",&n);
s = 2 * n + 1;t = 2 * n + 2;
for(int i = 1 ; i <= n ; i ++){
addedge(s,i,1,0);
addedge(i + n,t,1,0);
}
for(int i = 1 ; i < n ; i ++){
for(int j = i + 1 ; j <= n ; j ++){
scanf("%d",&c);
addedge(i,j + n,1,c);
addedge(j,i + n,1,c);
}
}
MCMF(s,t);
}
int main()
{
int _;
scanf("%d",&_);
while(_--) solve();
return 0;
}1626: Time Warp
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define LL long long
#define N 25
#define MOD 19999997
#define INF 0x3f3f3f3f
#define EXP 1e-8
int t,hour,a,b,r,cas=1,m,s;
double minute,second;
char str[10];
void setA()
{
if(r<=0)
r+=360;
minute = r/5.5;
W(minute>=60)
{
hour++;
minute-=60;
}
if(hour>12)
hour-=12;
m = (int)minute;
}
void setT()
{
if(r>=0) r-=360;
minute=r/5.5;
hour--;
W(minute<=-60)
{
hour--;
minute+=60;
}
if(hour<=0)
hour+=12;
if(fabs(minute)<=EXP)
{
hour++;
if(hour>12)
hour-=12;
}
else minute+=60;
m = (int)minute;
}
int main()
{
scanf("%d",&t);
W(t--)
{
scanf("%d%s%d",&a,str,&hour);
b = 30*(12-hour);
r = a-b;
if(str[0]=='a')
setA();
else
setT();
second = (minute-(int)minute)*60;
s = (int)(second+0.5);
printf("Case %d: %d:%02d:%02d\n",cas++,hour,m,s);
}
return 0;
}1630: Plane Ticket Pricing
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL __int64
#define N 25
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int n,w;
int dp[55][305];//第i天，出售的座位总数为j的收益
int path[55][305];//第i天，出售的座位总数为j的第一天的销售价格
struct node
{
int len,price[305],num[305];
}a[55];
int main()
{
int i,j,k,tem;
W(~scanf("%d%d",&n,&w))
{
UP(i,1,w+1)
{
scanf("%d",&a[i].len);
UP(j,1,a[i].len)
{
scanf("%d",&a[i].price[j]);
}
UP(j,1,a[i].len)
{
scanf("%d",&a[i].num[j]);
}
}
MEM(dp,-1);
UP(i,1,a[1].len)
{
tem = min(a[1].num[i],n);
dp[1][tem]=tem*a[1].price[i];
path[1][tem] = a[1].price[i];
}
UP(i,2,w+1)
{
UP(j,0,n)
{
if(dp[i-1][j]==-1) continue;
UP(k,1,a[i].len)
{
tem = min(n,j+a[i].num[k]);
if(dp[i][tem]<dp[i-1][j]+(tem-j)*a[i].price[k] || (dp[i][tem]==dp[i-1][j]+(tem-j)*a[i].price[k] && path[i][tem]>a[i].price[k]))
{
path[i][tem]=path[i-1][j];
dp[i][tem]=dp[i-1][j]+(tem-j)*a[i].price[k];
}
}
}
}
int s1=-1,s2;
UP(i,0,n)
{
if(s1<dp[w+1][i])
{
s1 = dp[w+1][i];
s2 = path[w+1][i];
}
}
printf("%d\n%d\n",s1,s2);
}
return 0;
}1631: Facility Locations
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 25
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int n,m,k;
int vis[105];
int main()
{
int i,j,k,x;
W(~scanf("%d%d%d",&n,&m,&k))
{
int mm = 0,kk = 0;
MEM(vis,0);
UP(i,1,n)
{
int flag = 0;
UP(j,1,m)
{
scanf("%d",&x);
if(x || vis[j]) continue;
if(!flag) kk++;
flag = 1;
vis[j] = 1;
mm++;
}
}
if(mm == m&&kk<=k)
puts("yes");
else
puts("no");
}
return 0;
}1632: Repeated Substrings
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <map>
using namespace std;
const int N=200010;
const int INF=0x7FFFFFFF;
struct Sa
{
char s[N];
int rk[2][N],sa[N],h[N],w[N],now,n;
int rmq[N][20],lg[N],bel[N];
bool GetS()
{
scanf("%s",s+1);
return true;
}
void getsa(int z,int &m)
{
int x=now,y=now^=1;
for(int i=1; i<=z; i++) rk[y][i]=n-i+1;
for(int i=1,j=z; i<=n; i++)
if(sa[i]>z) rk[y][++j]=sa[i]-z;
for(int i=1; i<=m; i++) w[i]=0;
for(int i=1; i<=n; i++) w[rk[x][rk[y][i]]]++;
for(int i=1; i<=m; i++) w[i]+=w[i-1];
for(int i=n; i>=1; i--) sa[w[rk[x][rk[y][i]]]--]=rk[y][i];
for(int i=m=1; i<=n; i++)
{
int *a=rk[x]+sa[i],*b=rk[x]+sa[i-1];
rk[y][sa[i]]=*a==*b&&*(a+z)==*(b+z)?m-1:m++;
}
}
void getsa(int m)
{
now=rk[1][0]=sa[0]=s[0]=0;
n=strlen(s+1);
for(int i=1; i<=m; i++) w[i]=0;
for(int i=1; i<=n; i++) w[s[i]]++;
for(int i=1; i<=m; i++) rk[1][i]=rk[1][i-1]+(bool)w[i];
for(int i=1; i<=m; i++) w[i]+=w[i-1];
for(int i=1; i<=n; i++) rk[0][i]=rk[1][s[i]];
for(int i=1; i<=n; i++) sa[w[s[i]]--]=i;
rk[1][n+1]=rk[0][n+1]=0;
for(int x=1,y=rk[1][m]; x<=n&&y<=n; x<<=1) getsa(x,y);
for(int i=1,j=0; i<=n; h[rk[now][i++]]=j?j--:j)
{
if(rk[now][i]==1) continue;
int k=n-max(sa[rk[now][i]-1],i);
while(j<=k&&s[sa[rk[now][i]-1]+j]==s[i+j]) ++j;
}
}
void getrmq()
{
h[n+1]=h[1]=lg[1]=0;
for(int i=2; i<=n; i++)
rmq[i][0]=h[i],lg[i]=lg[i>>1]+1;
for(int i=1; (1<<i)<=n; i++)
{
for(int j=2; j<=n; j++)
{
if(j+(1<<i)>n+1) break;
rmq[j][i]=min(rmq[j][i-1],rmq[j+(1<<i-1)][i-1]);
}
}
}
int lcp(int x,int y)
{
int l=min(rk[now][x],rk[now][y])+1,r=max(rk[now][x],rk[now][y]);
return min(rmq[l][lg[r-l+1]],rmq[r-(1<<lg[r-l+1])+1][lg[r-l+1]]);
}
void work()
{
getsa(300);
int ans=h[2];
for(int i=3;i<=n;i++)
if(h[i]>h[i-1])
ans+=h[i]-h[i-1];
printf("%d\n",ans);
}
} sa;
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
sa.GetS();
sa.work();
}
return 0;
}1633: Landline Telephone Network
#include<stdio.h>
#include<string.h>
const int N = 1005;
const int INF = 1<<28;
int mapt[N][N],n,flag[N],p;
int prime(){
int s[N],dis[N],mint,m,tm,k=0,sum=0;
for(int i=1; i<=n; i++){
s[i]=0; dis[i]=INF;
if(flag[i]==0)
m=i,k=1;
}
if(k==0)
return 0;
dis[m]=0; s[m]=1; tm=m;
while(k<n-p){
mint=INF;
for(int i=1; i<=n; i++)
if(!s[i]&&flag[i]==0){
if(dis[i]>mapt[m][i])
dis[i]=mapt[m][i];
if(mint>dis[i])
mint=dis[i],tm=i;
}
if(mint==INF)return -1;
m=tm; s[m]=1; sum+=mint; k++;
}
return sum;
}
int main(){
int m,a,b,c,aa[N];
while(scanf("%d%d%d",&n,&m,&p)>0){
for(int i=1; i<=n; i++){
flag[i]=0;
for(int j=1; j<=n;j++)
mapt[i][j]=INF;
}
for(int i=1; i<=p; i++){
scanf("%d",&a);
flag[a]=1; aa[i]=a;
}
while(m--){
scanf("%d%d%d",&a,&b,&c);
if(c<mapt[a][b])
mapt[a][b]=mapt[b][a]=c;
}
int sum=prime();
if(sum==-1)
printf("impossible\n");
else{
if(n-p==0)
{
if(p==1)printf("0\n");
else if(p==2){
a=aa[1]; b=aa[2];
if(mapt[a][b]==INF)
printf("impossible\n");
else printf("%d\n",mapt[a][b]);
}
else printf("impossible\n");
continue;
}
int i,j,mint;
for(i=1; i<=p; i++){
a=aa[i]; mint=INF;
for(j=1;j<=n;j++)
if(mapt[a][j]<mint&&flag[j]==0)
mint=mapt[a][j];
if(mint==INF)
break;
sum+=mint;
}
if(i<=p)
printf("impossible\n");
else printf("%d\n",sum);
}
}
return 0;
}1634: Aquarium Tank
#include<cstdio>
#include<cmath>
#include<iostream>
#define PI acos(-1.0)
using namespace std;
struct Point
{
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
};
double hmax;
double D,L;
typedef Point Vector;
Vector operator + (Vector A,Vector B)
{
return Vector(A.x+B.x,A.y+B.y);
}
Vector operator - (Point A,Point B)
{
return Vector(A.x-B.x,A.y-B.y);
}
Vector operator * (Vector A,double p)
{
return Vector(A.x*p,A.y*p);
}
Vector operator / (Vector A,double p)
{
return Vector(A.x/p,A.y/p);
}
bool operator < (const Point& a,const Point& b)
{
return a.x<b.x||(a.x==b.x && a.y<b.y);
}
const double eps = 1e-8;
int dcmp(double x)
{
if(fabs(x)<eps)return 0;
else return x < 0 ? -1 : 1;
}
bool operator == (const Point& a,const Point& b)
{
return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y)==0;
}
double Dot(Vector A,Vector B)
{
return A.x*B.x+A.y*B.y;
}
double length(Vector A)
{
return sqrt(Dot(A,A));
}
double Angle(Vector A,Vector B)
{
return acos(Dot(A,B)/length(A)/length(B));
}
double Cross(Vector A,Vector B)
{
return A.x*B.y-B.x*A.y;
}
double Area2(Point A,Point B,Point C)
{
return Cross(B-A,C-A);
}
double PArea(Point *p,int n)
{
double area=0;
for(int i=0; i<n; i++)
{
area+=Cross(p[i],p[(i+1)%n]);
}
return fabs(area/2);
}
Point GetLineIntersection(Point P,Vector v,Point Q,Vector w)
{
Vector u=P-Q;
return P+v*Cross(w,u)/Cross(v,w);
}
Point read_point(Point &P)
{
scanf("%lf%lf",&P.x,&P.y);
hmax=max(hmax,P.y);
return P;
}
Point get_point(Point a, Point b, double y0)
{
if(fabs(a.x - b.x) < eps) return Point(a.x, y0);
double bi = (y0 - a.y) / (b.y - a.y);
return Point(a.x + bi * (b.x - a.x), a.y + bi * (b.y - a.y));
}
int main()
{
Point po[105],Q[105];
int T,n,q,i;
while(scanf("%d",&n)!=EOF)
{
scanf("%lf%lf",&D,&L);
hmax=0;
for(i=0; i<n; i++)
{
read_point(po[i]);
}
double d=0,h=hmax;
while(h-d>eps)
{
q=0;
int per=n-1;
double m=(d+h)/2;
Point M(0,m);
Vector w(1,0);
for(int i=0; i<n; i++)
{
if((m-po[i].y)*(m-po[per].y)<eps)
{
Vector PP=po[i]-po[per];
Q[q++]=GetLineIntersection(po[per],PP,M,w);
// Q[q++]=get_point(po[i],po[per],m);
}
if((m-po[i].y)>eps)
{
Q[q++]=po[i];
}
per=i;
}
double area=PArea(Q,q);
if(L*1000-area*D>eps) d=m;
else h=m;
}
printf("%.2f\n",d);
}
return 0;
}1635: Restaurant Ratings
#include <iostream>
using namespace std;
typedef long long LL;
const int maxn = 35;
LL dp[maxn][maxn] = {1},ret;
int d[maxn],n,sum;
int main(){
for(int i = 1; i < 16; ++i){
for(int j = 0; j <= 30; ++j)
for(int k = 0; k <= j; ++k)
dp[i][j] += dp[i-1][j - k];//i个评委共打出j分的总数
}
while(scanf("%d",&n),n){
for(int i = sum = 0; i < n; ++i){
scanf("%d",d+i);
sum += d[i];
}
ret = 1;
for(int i = 0; i < sum; ++i) ret += dp[n][i];//小于
for(int i = 0; i < n; ++i){//等于
for(int j = 0; j < d[i]; ++j)
ret += dp[n-i-1][sum - j];//第1个评委打j分，剩下n-i-1个评委共打sum - j分
sum -= d[i];
}
printf("%lld\n",ret);
}
return 0;
}1637: Yet Satisfiability Again!
#include<iostream>
#define pii pair<int,int>
#include<vector>
using namespace std;
const int maxn = 200;
char str[maxn];
vector< pii >s[maxn];
int n, m;
void exp2num(int idx) {
bool flag = true;
for (int i = 0, ret = 0; str[i];) {
if (str[i] == '~') flag = false;
if (isdigit(str[i])) {
while (isdigit(str[i])) ret = ret * 10 + (str[i++] - '0');
s[idx].push_back(make_pair(ret - 1, flag));
ret = 0;
flag = true;
}
else i++;
}
}
bool check(int o){
for (int i = 0; i < m; ++i){
bool flag = false;
for (int j = s[i].size() - 1; j >= 0; --j){
if (s[i][j].second == ((o >> s[i][j].first) & 1)){
flag = true;
break;
}
}
if (!flag) return false;
}
return true;
}
int main(){
int T;
scanf("%d", &T);
while (T--){
scanf("%d %d", &n, &m);
getchar();
for (int i = 0; i < m; ++i){
s[i].clear();
gets(str);
exp2num(i);
}
bool ok = false;
for (int i = 0; i < (1 << n) && !ok; ++i)
ok = check(i);
puts(ok ? "satisfiable" : "unsatisfiable");
}
return 0;
}1639: 队长，我想进集训队！
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 100005;
int T, n, m, x1, x2, x3, tot;
char s[10];
int main()
{
while (cin >> T)
{
while (T--)
{
scanf("%s%d%d%d%d%d", s, &x1, &x2, &x3, &n, &m);
tot = x1 + 2 * x2 + 5 * x3 + n + m;
if (s[0] == 'm')
{
if (tot >= 90) printf("Welcome\n");
else printf("%d\n", 90 - tot);
}
else
{
if (tot >= 60) printf("Welcome\n");
else printf("%d\n", 60 - tot);
}
}
}
return 0;
}1640: 机智的刷题方式
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN=1000005;
int dp[MAXN];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
memset(dp,0,sizeof(dp));
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
int h,x;
scanf("%d%d",&h,&x);
int ans=0;
int score=0;
for(int i=0;i<=x||ans==0;i++)
{
if(i>=a)
dp[i]=max(dp[i],dp[i-a]+1);
if(i>=b)
dp[i]=max(dp[i],dp[i-b]+2);
if(i>=c)
dp[i]=max(dp[i],dp[i-c]+5);
if(dp[i]>=h&&ans==0)
ans=i;
if(i<=x)
score=max(dp[i],score);
}
printf("%d\n%d\n",ans,score);
}
return 0;
}1644: 超能陆战队
#include <iostream>
using namespace std;
const int maxn = 1000010;
int a,b,p,tot,prime[maxn],uf[maxn];
bool vis[maxn] = {true,true};
void selectPrime(){
for(int i = 2; i < maxn; ++i){
if(!vis[i]) prime[tot++] = i;
for(int j = 0; j < tot && prime[j]*i < maxn; ++j){
vis[i*prime[j]] = true;
if(i%prime[j] == 0) break;
}
}
}
int Find(int x){
int t = x;
while(uf[x] != x) x = uf[x];
while(uf[t] != t){
int tmp = uf[t];
uf[t] = x;
t = tmp;
}
return x;
}
int main(){
selectPrime();
while(~scanf("%d %d %d",&a,&b,&p)){
if(a > b) swap(a,b);
if(p > b){
printf("%d\n",b - a + 1);
continue;
}
for(int i = a; i <= b; ++i) uf[i] = i;
for(int i = 0; i < tot && prime[i] <= b; ++i){
if(prime[i] >= p){
int t = a/prime[i]*prime[i];
while(t < a) t += prime[i];
int s = t + prime[i];
while(s <= b){
int x = Find(t);
int y = Find(s);
if(x != y) if(i&1) uf[x] = y;else uf[y] = x;
s += prime[i];
}
}
}
int ans = 0;
for(int i = a; i <= b; ++i)
if(uf[i] == i) ans++;
printf("%d\n",ans);
}
return 0;
}1646: HearthStone
#include<iostream>
using namespace std;
#include<string.h>
int dp[25][210][210];//定义dp[i][j][k] 定义当前i轮过后使用了j张法师，k个刺骨的最大伤害
int main()
{
int T;scanf("%d",&T);
while(T--){
int r,n,m;scanf("%d%d%d",&r,&n,&m);
memset(dp,-1,sizeof(dp));
dp[1][0][0]=0;
for(int i=1;i<r;i++){
for(int j=0;j<=n;j++){
for(int k=0;k<=m;k++){
if(dp[i][j][k]==-1) continue;
int f=(i+1)<10 ? (i+1): 10;
for(int d=0;d<=f/3;d++){
if(j+d<=n){
for(int c=0;c<=f/2;c++){
if(k+c<=m&&d*3+c*2<=f){
if(d==0&&c!=0) dp[i+1][j][k+c]=max(dp[i+1][j][k+c],dp[i][j][k]+j+(j+d+4)*c-2);
else dp[i+1][j+d][k+c]=max(dp[i+1][j+d][k+c],dp[i][j][k]+j+(j+d+4)*c);
}
}
}
}
}
}
}
int maxn=0;
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
maxn=max(maxn,dp[r][i][j]);
}
}
printf("%d\n",maxn);
}
}1648: Swipe
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 20005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int a[1005],t,n;
int main()
{
int i,j,k;
scanf("%d",&t);
W(t--)
{
scanf("%d",&n);
UP(i,0,n-1)
{
scanf("%d",&a[i]);
}
if(n==1)
{
if(a[0]%4)
printf("%d\n",a[0]/4+1);
else
printf("%d\n",a[0]/4);
continue;
}
sort(a,a+n);
int ans = 0;
W(a[n-1]-ans>0)
{
ans++;
a[n-1]-=3;
for(i = n-2; i>=0; i--)
{
if(a[n-1]>a[i]||i==0)
{
int tem = a[i+1];
a[i+1] = a[n-1];
for(j=n-1; j>=i+3; j--)
a[j]=a[j-1];
a[i+2] = tem;
break;
}
}
}
printf("%d\n",ans);
}
return 0;
}1649: Transfer
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 20005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int num[10] = {6,2,5,5,4,5,6,3,7,6};
int bit[10] = {119,20,110,62,29,59,123,22,127,63};
int fun(int x)
{
int cnt = 0;
W(x)
{
if(x&1)
cnt++;
x/=2;
}
return cnt;
}
int main()
{
int i,j,k;
int a,b,c;
char x,y;
W(~scanf("%d%c%d%c%d",&a,&x,&b,&y,&c))
{
int cnt = 0,flag;
flag = (x=='+')?2:1;
cnt+=flag;
cnt+=num[a]+num[b]+num[c];
int s,sum,minn = INF;
UP(i,0,9)
{
UP(j,0,9)
{
UP(k,1,2)
{
if(k==1)
{
s = i-j;
if(s<0) continue;
sum=k;
}
else
{
s = i+j;
if(s>9) continue;
sum=k;
}
sum+=num[i]+num[j]+num[s];
if(sum!=cnt) continue;
//计算不同位置的火柴的根数，偶数时可行的
int p=(k==flag)?0:1;
p+=fun(bit[a]^bit[i])+fun(bit[b]^bit[j])+fun(bit[c]^bit[s]);
if(p%2==0)
{
p/=2;
minn = min(p,minn);
}
}
}
}
printf("%d\n",minn==INF?-1:minn);
}
return 0;
}1650: 影魔大战
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 1005;
int x, y, vx, r1, r2, t1, t2;
double t[3][3];
bool flag;
int main()
{
while (scanf("%d%d%d", &vx, &x, &y) != EOF)
{
scanf("%d%d%d%d", &t1, &r1, &t2, &r2);
flag = false;
if (r1 < y || r2 < y) flag = false;
else
{
t[1][0] = (x + sqrt(1.0*r1*r1 - y*y)) / vx;
t[1][1] = (x - sqrt(1.0*r1*r1 - y*y)) / vx;
t[2][0] = (x + sqrt(1.0*r2*r2 - y*y)) / vx;
t[2][1] = (x - sqrt(1.0*r2*r2 - y*y)) / vx;
for (int i = 0; i <= 1;i++)
for (int j = 0; j <= 1; j++)
{
if (t[1][i]>=t1&&t[2][j] - t[1][i]>=t2) flag = true;
if (t[2][i]>=t2&&t[1][j] - t[2][i]>=t1) flag = true;
}
}
printf("%s\n", flag ? "Yes" : "No");
}
return 0;
}1651: Weirdo
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 40001;
const int INF = 0x3f3f3f3f;
struct arc{
int u,v,w;
bool operator<(const arc &t) const{
return w < t.w;
}
}e[maxn];
int uf[maxn],n,m,S,T,ret;
bool flag;
int Find(int x){
int t = x;
while(uf[x] != x) x = uf[x];
while(uf[t] != t){
int tmp = uf[t];
uf[t] = x;
t = tmp;
}
return x;
}
int kruskal(int low){
for(int i = 0; i <= n; ++i) uf[i] = i;
for(int i = low; i < m; ++i){
int x = Find(e[i].u);
int y = Find(e[i].v);
if(x == y) continue;
uf[x] = y;
if(Find(S) == Find(T)) return e[i].w - e[low].w;
if((LL)e[low].w + ret <= e[i].w) return INF;
}
flag = false;
return INF;
}
int main(){
while(~scanf("%d %d %d %d",&n,&m,&S,&T)){
for(int i = 0; i < m; ++i)
scanf("%d %d %d",&e[i].u,&e[i].v,&e[i].w);
sort(e,e+m);
ret = INF;
flag = true;
for(int i = 0; i < m && flag; ++i)
ret = min(kruskal(i),ret);
printf("%d\n",ret);
}
return 0;
}1654: 收集金币
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 20005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
int n,a[100005],hsh[100005];
int v,t,s,x;
int main()
{
int i,j,k;
W(~scanf("%d",&n))
{
UP(i,1,n)
{
scanf("%d",&a[i]);
hsh[a[i]] = i;
}
s = 1;
v = t = 0;
W(s<=n)
{
int cnt = 1;
W(hsh[s+1]>hsh[s])
{
s++;
cnt++;
}
v+=cnt*cnt;
t+=hsh[s];
s++;
}
printf("%d %d\n",v,t);
}
return 0;
}1655: 文本计算器
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
using namespace std;
const int N = 1505;
char fh[N],s[N]; //符号栈，表达式
double num[N]; //数字栈
int ftop,ntop; //符号栈顶，数字栈顶
void calculate(){
if(fh[ftop]=='+')
num[ntop-1]+=num[ntop],ntop--;
else if(fh[ftop]=='-')
num[ntop-1]-=num[ntop],ntop--;
else if(fh[ftop]=='*')
num[ntop-1]*=num[ntop],ntop--;
else if(fh[ftop]=='/')
num[ntop-1]/=num[ntop],ntop--;
ftop--;
}
int main(){
while(scanf("%s",s)>0){
ftop=0;ntop=0;
int flagNum=0,flagNode=0,slen=strlen(s);
double ans=0,EE;
for(int i=0; i<=slen; ++i){
if(i!=slen&&(s[i]>='0'&&s[i]<='9'||s[i]=='.')){
if(s[i]=='.')flagNode=1,EE=0.1;
else{
if(flagNode){
ans+=(s[i]-'0')*EE; EE*=0.1;
}
else ans=ans*10+s[i]-'0';
flagNum=1;
}
}
else{
if(flagNum)num[++ntop]=ans; flagNum=0; flagNode=0; ans=0;
if(i==slen)break;
if(s[i]=='+'||s[i]=='-'){
while(ftop&&fh[ftop]!='(') calculate();
fh[++ftop]=s[i];
}
else if(s[i]==')'){
while(ftop&&fh[ftop]!='(') calculate(); ftop--;
}
else if(s[i]=='*'||s[i]=='/'){
while(ftop&&(fh[ftop]=='*'||fh[ftop]=='/')) calculate();
fh[++ftop]=s[i];
}
else fh[++ftop]=s[i];
}
}
while(ftop) calculate();
printf("%.4f\n",num[1]);
}
}1656: Paper of FlyBrother
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define LS 2*i
#define RS 2*i+1
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 100005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
LL wa[N],wb[N],wsf[N],wv[N],sa[N];
LL rank1[N],height[N],s[N],a[N];
char str[N],str1[N],str2[N];
//sa:字典序中排第i位的起始位置在str中第sa[i]
//rank:就是str第i个位置的后缀是在字典序排第几
//height：字典序排i和i-1的后缀的最长公共前缀
LL cmp(LL *r,LL a,LL b,LL k)
{
return r[a]==r[b]&&r[a+k]==r[b+k];
}
void getsa(LL *r,LL *sa,LL n,LL m)//n要包含末尾添加的0
{
LL i,j,p,*x=wa,*y=wb,*t;
for(i=0; i<m; i++) wsf[i]=0;
for(i=0; i<n; i++) wsf[x[i]=r[i]]++;
for(i=1; i<m; i++) wsf[i]+=wsf[i-1];
for(i=n-1; i>=0; i--) sa[--wsf[x[i]]]=i;
p=1;
j=1;
for(; p<n; j*=2,m=p)
{
for(p=0,i=n-j; i<n; i++) y[p++]=i;
for(i=0; i<n; i++) if(sa[i]>=j) y[p++]=sa[i]-j;
for(i=0; i<n; i++) wv[i]=x[y[i]];
for(i=0; i<m; i++) wsf[i]=0;
for(i=0; i<n; i++) wsf[wv[i]]++;
for(i=1; i<m; i++) wsf[i]+=wsf[i-1];
for(i=n-1; i>=0; i--) sa[--wsf[wv[i]]]=y[i];
t=x;
x=y;
y=t;
x[sa[0]]=0;
for(p=1,i=1; i<n; i++)
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)? p-1:p++;
}
}
void getheight(LL *r,LL n)//n不保存最后的0
{
LL i,j,k=0;
for(i=1; i<=n; i++) rank1[sa[i]]=i;
for(i=0; i<n; i++)
{
if(k)
k--;
else
k=0;
j=sa[rank1[i]-1];
while(r[i+k]==r[j+k])
k++;
height[rank1[i]]=k;
}
}
LL t,ans,n,m;
int main()
{
LL i,j,k,len;
W(~scanf("%s",str))
{
len = strlen(str);
UP(i,0,len-1)
s[i]=str[i];
s[len] = 0;
getsa(s,sa,len+1,300);
getheight(s,len);
ans = (1+len)*len/2;
UP(i,2,len)
ans-=height[i];
printf("%lld\n",ans);
}
}1657: Ways
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
using namespace std;
int a[1010][1010][2], f[4][2] = {0,1,1,0,0,-1,-1,0};
int vis[1010][1010], n;
int dp[1010][1010][2][2];
struct node
{
int x, y;
}s, e;
int bfs()
{
memset(vis, 0, sizeof(vis));
memset(dp, 0x3f3f3f3f, sizeof(dp));
queue<node>q;
s.x=1, s.y=1;
if(a[1][1][0]<=a[1][1][1])
{
dp[1][1][0][0] = a[1][1][0];
dp[1][1][0][1] = a[1][1][1];
}
else
{
dp[1][1][1][0] = a[1][1][0];
dp[1][1][1][1] = a[1][1][1];
}
vis[1][1]=1, q.push(s);
while(!q.empty())
{
s=q.front(), q.pop();
for(int i=0; i<4; i++)
{
e.x = s.x+f[i][0];
e.y = s.y+f[i][1];
if(e.x<1||e.x>n||e.y<1||e.y>n) continue;
for(int k=0; k<2; k++)
{
int n2 = dp[s.x][s.y][k][0]+a[e.x][e.y][0];
int n5 = dp[s.x][s.y][k][1]+a[e.x][e.y][1];
if(n2<=n5 && dp[e.x][e.y][0][0]>n2)
{
dp[e.x][e.y][0][0] = n2;
dp[e.x][e.y][0][1] = n5;
if(!vis[e.x][e.y])
{
vis[e.x][e.y]=1, q.push(e);
}
}
else if(n2>n5 && dp[e.x][e.y][1][1]>n5)
{
dp[e.x][e.y][1][0] = n2;
dp[e.x][e.y][1][1] = n5;
if(!vis[e.x][e.y])
{
vis[e.x][e.y]=1, q.push(e);
}
}
}
}
}
return min(dp[n][n][0][0], dp[n][n][1][1]);
}
int main()
{
while(~scanf("%d", &n))
{
int x;
for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
{
scanf("%d", &x);
int num2=0, num5=0;
while(x%2==0) num2++, x/=2;
while(x%5==0) num5++, x/=5;
a[i][j][0] = num2;
a[i][j][1] = num5;
}
}
printf("%d\n", bfs());
}
return 0;
}1658: IQ of XUEXX’s descendants
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
typedef long long LL;
LL block[2][2];///存储矩阵
LL tblock[2][2];
LL x,y;
void mul1(LL p)
{
for(int i=0; i<2; i++){
for(int j=0; j<2; j++){
tblock[i][j] = 0;
for(int k=0; k<2; k++)
tblock[i][j] = (tblock[i][j] + block[i][k] * block[k][j]) % p;///1 1 = 10 * 0 1 + 11 * 11
}
}
for(int i=0; i<2; i++)
for(int j=0; j<2; j++)
block[i][j] = tblock[i][j];
}
void mul2(LL p)
{
LL ans = 0;
LL t1,t2;
t2 = block[0][1] * x % p + block[1][1] * y % p;
t1 = block[0][0] * x % p + block[1][0] * y % p;
x = t1 % p;
y = t2 % p;
}
int main()
{
int t;
scanf("%d",&t);
for(int cas = 1; cas <= t; cas++){
LL a,b,p,n;
scanf("%lld %lld %lld %lld %lld %lld",&x,&y,&a,&b,&p,&n);
block[0][0] = 0;
block[0][1] = a;
block[1][0] = 1;
block[1][1] = b;
LL ans = 0;
while(n){
if(n & 1) mul2(p);
mul1(p);
n = n >> 1;
}
printf("Case #%d: %lld\n",cas,y);
}
return 0;
}1659: Graph Center
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <list>
#include <algorithm>
#include <climits>
using namespace std;
#define lson 2*i
#define rson 2*i+1
#define LS l,mid,lson
#define RS mid+1,r,rson
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 200005
#define INF 0x3f3f3f3f
#define EXP 1e-8
#define lowbit(x) (x&-x)
const int mod = 1e9+7;
const int L = 10005;
struct Edges
{
int x,y,w,next;
} e[L<<2];
int head[L],n,m;
int dis[L];
int vis[L];
int cnt[L],hash[L],ss[L];
int s[L];
void init()
{
memset(e,-1,sizeof(e));
memset(head,-1,sizeof(head));
}
void AddEdge(int x,int y,int w,int k)
{
e[k].x = x,e[k].y = y,e[k].w = w,e[k].next = head[x],head[x] = k;
}
int relax(int u,int v,int c)
{
if(dis[v]>dis[u]+c)
{
dis[v] = dis[u]+c;
return 1;
}
return 0;
}
int SPFA(int src)
{
int i;
memset(vis,0,sizeof(vis));
for(int i = 0; i<=n; i++)
dis[i] = INF;
dis[src] = 0;
queue<int> Q;
Q.push(src);
vis[src] = 1;
while(!Q.empty())
{
int u,v;
u = Q.front();
Q.pop();
vis[u] = 0;
for(i = head[u]; i!=-1; i=e[i].next)
{
v = e[i].y;
if(relax(u,v,e[i].w)==1 && !vis[v])
{
Q.push(v);
vis[v] = 1;
}
}
}
int maxn = -1;
for(i = 1; i<=n; i++)
maxn = max(maxn,dis[i]);
return maxn;
}
int ans[L],tot,p[N];
int main()
{
int t,u,v,i,j,k;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
init();
for(i = 0; i<2*m; i+=2)
{
scanf("%d%d",&u,&v);
AddEdge(u,v,1,i);
AddEdge(v,u,1,i+1);
}
int minn = INF;
for(i = 1; i<=n; i++)
{
p[i] = SPFA(i);
minn = min(p[i],minn);
}
tot = 0;
for(i = 1; i<=n; i++)
{
if(p[i]==minn)
ans[tot++] = i;
}
printf("%d\n",tot);
for(i = 0; i<tot; i++)
{
if(i)
printf(" ");
printf("%d",ans[i]);
}
printf("\n");
}
return 0;
}1661: Query Mutiple
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <list>
#include <algorithm>
#include <climits>
using namespace std;
#define lson 2*i
#define rson 2*i+1
#define LS l,mid,lson
#define RS mid+1,r,rson
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 1000000
#define INF 0x3f3f3f3f
#define EXP 1e-8
#define lowbit(x) (x&-x)
const int mod = 1e9+7;
vector<int> prime[N+5];
bool vis[N+5];
int pos[N+5],tot;
void sett()
{
int i,j;
memset(vis,1,sizeof(vis));
for(i = 2; i<=N; i++)
{
if(vis[i])
{
if(N/i<i)
break;
}
for(j = (LL)i+i; j<=N; j+=i)
vis[j] = 0;
}
tot = 1;
for(i = 2; i<=N; i++)
if(vis[i])
pos[i] = tot++;
}
int main()
{
sett();
int i,j,n,m,x,y,l,r,L,R;
while(~scanf("%d%d",&n,&m))
{
for(i = 1; i<tot; i++)
prime[i].clear();
for(i = 1; i<=n; i++)
{
scanf("%d",&x);
for(j = 2; j*j<=x; j++)
{
if(x%j!=0)
continue;
prime[pos[j]].push_back(i);
while(x%j==0)
x/=j;
}
if(x>1)
prime[pos[x]].push_back(i);
}
for(i = 1; i<tot; i++)
sort(prime[i].begin(),prime[i].end());
while(m--)
{
scanf("%d%d%d",&l,&r,&x);
y = pos[x];
int len = prime[y].size();
if(len==0||l>prime[y][len-1]||r<prime[y][0])
{
printf("0\n");
continue;
}
L = lower_bound(prime[y].begin(),prime[y].end(),l)-prime[y].begin();
R = lower_bound(prime[y].begin(),prime[y].end(),r)-prime[y].begin();
if(R==len||prime[y][R]>r)
R--;
printf("%d\n",R-L+1);
}
}
return 0;
}1663: Tree
#include<stdio.h>
#include<string.h>
#define LL long long
const int N = 50005;
int head[N<<1],to[N<<1],next1[N<<1],tot;
int deep[N],fath[N],son[N],num[N];
int top[N],p[N],pos;
void init(){
pos=tot=0;
memset(head,-1,sizeof(head));
}
void addEdge(const int& u, const int& v){
to[tot] = v, next1[tot] = head[u], head[u] = tot++;
}
void addUndirEdge(const int& u, const int& v){
addEdge(u, v), addEdge(v, u);
}
void dfs1(int u,int pre,int d){
fath[u]=pre;
deep[u]=d;
son[u]=-1;
num[u]=1;
for(int i=head[u]; i!=-1; i=next1[i]){
int v=to[i];
if(v==fath[u])continue;
dfs1(v,u,d+1);
num[u]+=num[v];
if(son[u]==-1||num[v]>num[son[u]])
son[u]=v;
}
}
void getpos(int u,int root){
top[u]=root;
p[u]=pos++;
if(son[u]==-1)
return ;
getpos(son[u],root);
for(int i=head[u]; i!=-1; i=next1[i]){
int v=to[i];
if(v==son[u]||v==fath[u])
continue;
getpos(v,v);
}
}
struct TREE{
LL milt,sum;
}root[N*3];
LL cost[N];
void pushUp(int k){
root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
}
void pushDow(int k){
if(root[k].milt!=1)
{
root[k<<1].sum*=root[k].milt;
root[k<<1].milt*=root[k].milt;
root[k<<1|1].sum*=root[k].milt;
root[k<<1|1].milt*=root[k].milt;
root[k].milt=1;
}
}
void build(int l, int r, int k){
root[k].milt=1;
if(l==r){
root[k].sum=cost[l]; return ;
}
int mid=(l+r)>>1;
build(l,mid,k<<1);
build(mid+1,r,k<<1|1);
pushUp(k);
}
void update_C(int l, int r, int k, const int& id, LL c){
if(l==r){
root[k].sum=c; return ;
}
int mid=(l+r)>>1;
pushDow(k);
if(id<=mid)
update_C(l,mid,k<<1,id,c);
else
update_C(mid+1,r,k<<1|1,id,c);
pushUp(k);
}
void updata_M(int l,int r,int k,int L,int R,int M){
if(L<=l&&r<=R){
root[k].milt*=M; root[k].sum*=M;
return ;
}
pushDow(k);
int mid=(l+r)>>1;
if(L<=mid)
updata_M(l,mid,k<<1,L,R,M);
if(mid<R)
updata_M(mid+1,r,k<<1|1,L,R,M);
pushUp(k);
}
LL query(int l, int r, int k, const int& L, const int& R){
if(L<=l&&r<=R){
return root[k].sum;
}
pushDow(k);
int mid=(l+r)>>1;
LL sum=0;
if(L<=mid)
sum+=query(l,mid,k<<1,L,R);
if(mid<R)
sum+=query(mid+1,r,k<<1|1,L,R);
return sum;
}
void swp(int &u,int &v){
int tt=u; u=v; v=tt;
}
LL solve(int u,int v,int flag,LL M){
int fu=top[u], fv=top[v];
LL sum=0;
while(fu!=fv){
if(deep[fu]<deep[fv]){
swp(fu,fv); swp(u,v);
}
if(flag==0)
updata_M(1,pos,1,p[fu],p[u],M);
else
sum+=query(1,pos,1,p[fu],p[u]);
u=fath[fu]; fu=top[u];
}
if(u==v)return sum;
if(deep[u]>deep[v])
swp(u,v);
if(flag==0)
updata_M(1,pos,1,p[son[u]],p[v],M);
else
sum+=query(1,pos,1,p[son[u]],p[v]);//一不小心p[son[u]]写成了p[u]让我WA了好几次（求边权用p[son[u]],求点权用p[u]）
return sum;
}
struct EDG{
int u,v;
LL c;
}edg[N];
int main()
{
int n,m,a,b,T;
char op[10];
scanf("%d",&T);
while(T--){
scanf("%d",&n);
init();
for(int i=1; i<n; i++){
scanf("%d%d%lld",&edg[i].u,&edg[i].v,&edg[i].c);
addUndirEdge(edg[i].u, edg[i].v);
}
dfs1(1,1,1);
getpos(1,1);
for(int i=1; i<n; i++){
if(deep[edg[i].u]>deep[edg[i].v])
swp(edg[i].u, edg[i].v);
cost[p[edg[i].v]]=edg[i].c;
}
pos=n;
build(1,pos,1);
while(1){
scanf("%s",op);
if(op[0]=='E')
break;
scanf("%d%d",&a,&b);
if(op[0]=='C')
update_C(1,pos,1,p[edg[a].v],b);
else if(op[0]=='M'){
LL M;
scanf("%lld",&M);
solve(a,b,0,M);
}
else
printf("%lld\n",solve(a,b,1,1));
}
}
} 1664: 防水堤坝
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<map>
#include<math.h>
#include<string.h>
#include<queue>
#include<map>
#include<vector>
#include<set>
#define LL long long
#define exp 1e-9
#define MAXN 1000010
using namespace std;
int main()
{
LL n,x,y;
LL ans;
while(scanf("%lld",&n)!=EOF)
{
ans = 0;
x = n/4;
y = n%4;
if(y<2)ans = 4*x*x;
else ans = 4*x*(x+1);
if(y==1)ans+=2*x-1;
else if(y==3)ans+=2*x+1;
if(ans&1)printf("%lld.5\n",ans/2);
else printf("%lld.0\n",ans/2);
}
return 0;
}1670: 赌神的战斗
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int M=205;
double p[M][M];
double pp[M][2];
int main()
{
int t;
int h1,h2;
int aa1,aa2;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d%d",&aa1,&h1,&aa2,&h2);
if(aa1==1&&aa2==1)
{
printf("0.000 0.000\n");
continue;
}
if(aa1==1&&aa2!=1)
{
printf("0.000 1.000\n");
continue;
}
if(aa2==1&&aa1!=1)
{
printf("1.000 0.000\n");
continue;
}
memset(p,0,sizeof(p));
memset(pp,0,sizeof(pp));
for(int i=1;i<=h1;i++)
p[i][0]=1;
int tp,tpma;
if(aa1>aa2)
{
tp=aa2;
tpma=aa1;
}
else
{
tp=aa1;
tpma=aa2;
}
double ppp=aa1*aa2-tp;
for(int p1=1;p1<=aa2;p1++) //这个位置需要用矩阵做优化
{
for(int p2=1;p2<=aa1;p2++) //初始化系数矩阵
{
if(p1>p2)
pp[p1-p2][0]+=1;
if(p1<p2)
pp[p2-p1][1]+=1;
//cout<<tp<<endl;
//cout<<p1<<" "<<p2<<" "<<p[i][j]<<endl;
}
}
for(int i=1;i<=h1;i++)
{
for(int j=1;j<=h2;j++)
{
for(int k=1;k<=tpma;k++)
{
if(k<=i)
p[i][j]+=pp[k][0]*p[i-k][j];
if(k<=j)
p[i][j]+=pp[k][1]*p[i][j-k];
else
p[i][j]+=pp[k][1]*p[i][0];
}
p[i][j]=p[i][j]/ppp;
}
}
printf("%.3lf %.3lf\n",p[h1][h2],1-p[h1][h2]);
}
return 0;
}1671: 经营小卖部
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define N 1005
using namespace std;
typedef struct
{
int cost,value,type;
}Node;
Node a[N];
int dp[N];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int x,n,p1,p2;
scanf("%d%d%d%d",&x,&n,&p1,&p2);
for(int i=0;i<n;i++)
scanf("%d%d%d",&a[i].cost,&a[i].value,&a[i].type);
int ans=0;
memset(dp,0,sizeof(dp));
for(int i=1;i<=x;i++)
{
for(int j=0;j<n;j++)
if(i>=a[j].cost&&a[j].type==0)
dp[i]=max(dp[i],dp[i-a[j].cost]+a[j].value);
ans=max(ans,dp[i]-i);
}
memset(dp,0,sizeof(dp));
for(int i=1;i<=x-p1;i++)
{
for(int j=0;j<n;j++)
if(i>=a[j].cost&&a[j].type!=2)
dp[i]=max(dp[i],dp[i-a[j].cost]+a[j].value);
ans=max(ans,dp[i]-i-p1);
}
memset(dp,0,sizeof(dp));
for(int i=1;i<=x-p2;i++)
{
for(int j=0;j<n;j++)
if(i>=a[j].cost&&a[j].type!=1)
dp[i]=max(dp[i],dp[i-a[j].cost]+a[j].value);
ans=max(ans,dp[i]-i-p2);
}
memset(dp,0,sizeof(dp));
for(int i=1;i<=x-p1-p2;i++)
{
for(int j=0;j<n;j++)
if(i>=a[j].cost)
dp[i]=max(dp[i],dp[i-a[j].cost]+a[j].value);
ans=max(ans,dp[i]-i-p1-p2);
}
printf("%d\n",ans);
}
return 0;
}1672: Pool in minecraft
#include <stdio.h>
#include <queue>
#include <string.h>
#include <algorithm>
#define N 1005
using namespace std;
typedef struct Node
{
int x,y,h;
bool operator < (const Node &rhs) const {
return h > rhs.h ;
}
}Node;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
int grid[N][N];
int vis[N][N];
int n;
int bfs()
{
priority_queue<Node> q;
while(!q.empty())
q.pop();
Node fir;
for(int i=2;i<n;i++)
{
fir.x=1,fir.y=i,fir.h=grid[1][i],vis[1][i]=1;
q.push(fir);
fir.x=i,fir.y=n,fir.h=grid[i][n],vis[i][n]=1;
q.push(fir);
fir.x=n,fir.y=i,fir.h=grid[n][i],vis[n][i]=1;
q.push(fir);
fir.x=i,fir.y=1,fir.h=grid[i][1],vis[i][1]=1;
q.push(fir);
}
vis[1][n]=1,vis[1][1]=1,vis[n][1]=1,vis[n][n]=1;
int h=0,ans=0;
while(!q.empty())
{
Node fro=q.top();
q.pop();
if(fro.h<h)
ans+=h-fro.h;
h=max(fro.h,h);
for(int i=0;i<4;i++)
{
int xx=fro.x+dx[i];
int yy=fro.y+dy[i];
if(xx>n||xx<1||yy>n||yy<1||vis[xx][yy])
continue;
Node nxt;
nxt.x=xx,nxt.y=yy,nxt.h=grid[xx][yy],vis[xx][yy]=1;
q.push(nxt);
}
}
return ans;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
memset(vis,0,sizeof(vis));
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
scanf("%d",&grid[i][j]);
printf("%d\n",bfs());
}
return 0;
}1673: 集训队组队计划
#include <stdio.h>
#include <algorithm>
#define N 100005
using namespace std;
int a[N];
int n,m;
bool isok(int x)
{
int cnt=0;
for(int i=2;i<n;i++)
if(a[i]-a[i-2]<=x)
i+=2,cnt++;
if(cnt>=m)
return true;
return false;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
scanf("%d",&a[i]);
sort(a,a+n);
int minn=0,maxn=a[n-1];
while(minn<=maxn)
{
int mid=minn+(maxn-minn)/2;
if(isok(mid))
maxn=mid-1;
else
minn=mid+1;
}
printf("%d\n",minn);
}
return 0;
}1681: Adjoin
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cassert>
#define RI(N) scanf("%d",&(N))
#define RII(N,M) scanf("%d %d",&(N),&(M))
#define RIII(N,M,K) scanf("%d %d %d",&(N),&(M),&(K))
#define Cl0(a) memset((a),0,sizeof(a))
using namespace std;
const int inf=1e9;
const int inf1=-1*1e9;
typedef long long LL;
vector <int> g [100005];
bool used[100005];
bool used1[100005];
int ans[100005];
int maxx,maxxx;
int dfs(int p,int ans)
{
used[p]=1;
used1[p]=1;
int length=g[p].size();
int i=0;
for(; i<length; i++)
{
if(!used1[g[p][i]])
{
dfs(g[p][i],ans+1);
}
}
if(ans>maxx)
{
maxx=ans;
maxxx=p;
}
return maxxx;
}
int dfs1(int p,int ans)
{
used1[p]=1;
int length=g[p].size();
int i=0;
for(; i<length; i++)
{
if(!used1[g[p][i]])
{
dfs1(g[p][i],ans+1);
}
}
if(ans>maxx) maxx=ans;
return maxx;
}
int main()
{
int c,l,num=0;
while(RII(c,l)!=EOF)
{
memset(used,0,sizeof(used));
for(int i=0; i<l; i++)
{
int x,y;
RII(x,y);
g[x].push_back(y);
g[y].push_back(x);
}
for(int i=0; i<c; i++)
{
if(!used[i])
{
memset(used1,0,sizeof(used1));
maxx=-1;
int v=dfs(i,0);
memset(used1,0,sizeof(used1));
maxx=-1;
ans[num++]=dfs1(v,0);
}
}
sort(ans,ans+num);
int ans1=ans[num-1];
int ans2=0,ans3=0;
if(num>=3)
{
if(ans[num-1]==ans[num-2]&&ans[num-2]==ans[num-3])
ans2=(ans[num-1]+1)/2*2+2;
else ans2=(ans[num-1]+1)/2+(ans[num-2]+1)/2+1;
}
if(num==2) ans2=(ans[num-1]+1)/2+(ans[num-2]+1)/2+1;
cout<<max(ans1,ans2)<<endl;
for(int i=0;i<c;i++)
g[i].clear();
}
return 0;
}1684: Disastrous Downtime
#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define T 100000 + 50
struct node
{
ll v;
bool operator<(const node& b)const{
return v<b.v;
}
}a[T];
struct line
{
ll val;
line():val(0){}
line(ll _2):val(_2){}
bool operator<(const line& b)const{
return val>b.val;
}
};
ll v[T];
bool cmp(const ll& a,const ll& b){return a>b;}
int main()
{
int n,m,i,j;
while(~scanf("%d%d",&n,&m))
{
ll c = 0;
ll sum = 0;
for(i=0;i<n;++i){
scanf("%lld",&a[i].v);
}
sort(a,a+n);
fill(v,v+T,0);
multiset< ll,greater<int> > Q;
multiset< ll,greater<int> >::iterator it;
ll k;
Q.insert(a[0].v+1000);
ll cnt;
for(i=1;i<n;++i){
it = Q.begin();
k = *it;
it = Q.lower_bound(a[i].v);
if(it==Q.end()){
Q.insert(a[i].v+1000);
}
else if(it!=Q.end()){
Q.erase(it);
Q.insert(a[i].v+1000);
}
}
cnt = Q.size();
Q.clear();
if(cnt%m>0)cnt = cnt/m+1;
else cnt = cnt/m;
printf("%lld\n",cnt);
}
return 0;
}1685: Entertainment Box
#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define T 100000 + 50
struct node
{
ll L,R;
bool operator<(const node& b)const{
return R<b.R;
}
}a[T];
struct line
{
ll val;
line():val(0){}
line(ll _2):val(_2){}
bool operator<(const line& b)const{
return val>b.val;
}
};
ll v[T];
bool cmp(const ll& a,const ll& b){return a>b;}
int main()
{
#ifdef zsc
freopen("input.txt","r",stdin);
#endif
int n,m,i,j;
while(~scanf("%d%d",&n,&m))
{
ll c = 0;
ll sum = 0;
for(i=0;i<n;++i){
scanf("%lld%lld",&a[i].L,&a[i].R);
}
if(m>=n){
printf("%d\n",n);
continue;
}
sort(a,a+n);
fill(v,v+T,0);
multiset< ll,greater<int> > Q;
multiset< ll,greater<int> >::iterator it;
ll k;
Q.insert(a[0].R);
c = 1;
int cnt = 1;
for(i=1;i<n;++i){
it = Q.begin();
k = *it;
it = Q.lower_bound(a[i].L);
if(it==Q.end()&&cnt<m){
c ++;cnt++;
Q.insert(a[i].R);
}
else if(it!=Q.end()&&cnt<=m){
c++;
Q.erase(it);
Q.insert(a[i].R);
}
}
Q.clear();
printf("%lld\n",c);
}
return 0;
}1692: Vector Field
#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<cstdio>
#include<cctype>
#include<bitset>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define fuck(x) cout<<"["<<x<<"]"
#define FIN freopen("input.txt","r",stdin)
#define FOUT freopen("output.txt","w+",stdout)
//#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
typedef long long LL;
const int MX = 3e3 + 5;
struct Point {
int x, y, d; //下左上右
} P[MX];
struct Data {
int val, id;
Data() {}
Data(int _id, int _val) {
val = _val; id = _id;
}
bool operator<(const Data &P) const {
return val < P.val;
}
};
set<Data>X[MX], Y[MX];
int tmpX[MX], tmpY[MX];
int solve(int u) {
int begin = u;
set<Data>::iterator it;
int ret = 0;
while(true) {
ret++;
X[P[u].x].erase(Data(u, P[u].y));
Y[P[u].y].erase(Data(u, P[u].x));
if(P[u].d == 0) {
it = X[P[u].x].lower_bound(Data(0, P[u].y));
if(it == X[P[u].x].begin()) return ret;
it--;
}
if(P[u].d == 1) {
it = Y[P[u].y].lower_bound(Data(0, P[u].x));
if(it == Y[P[u].y].begin()) return ret;
it--;
}
if(P[u].d == 2) {
it = X[P[u].x].upper_bound(Data(0, P[u].y));
if(it == X[P[u].x].end()) return ret;
}
if(P[u].d == 3) {
it = Y[P[u].y].upper_bound(Data(0, P[u].x));
if(it == Y[P[u].y].end()) return ret;
}
//if(begin==5&&P[u].x==2&&P[u].y==1) fuck(P[u].d);
u = it->id;
}
return ret;
}
int main() {
int n; //FIN;
while(~scanf("%d", &n)) {
for(int i = 1; i <= n; i++) {
char w[10];
scanf("%d%d%s", &P[i].x, &P[i].y, w);
tmpX[i] = P[i].x; tmpY[i] = P[i].y;
if(w[0] == 'v') P[i].d = 2;
if(w[0] == '<') P[i].d = 1;
if(w[0] == '^') P[i].d = 0;
if(w[0] == '>') P[i].d = 3;
}
int sz1, sz2;
sort(tmpX + 1, tmpX + 1 + n);
sort(tmpY + 1, tmpY + 1 + n);
sz1 = unique(tmpX + 1, tmpX + 1 + n) - tmpX - 1;
sz2 = unique(tmpY + 1, tmpY + 1 + n) - tmpY - 1;
for(int i = 1; i <= n; i++) {
P[i].x = lower_bound(tmpX + 1, tmpX + 1 + sz1, P[i].x) - tmpX;
P[i].y = lower_bound(tmpY + 1, tmpY + 1 + sz2, P[i].y) - tmpY;
}
int ans = 0;
for(int u = 1; u <= n; u++) {
for(int i = 1; i <= sz1; i++) X[i].clear();
for(int i = 1; i <= sz2; i++) Y[i].clear();
for(int i = 1; i <= n; i++) {
X[P[i].x].insert(Data(i, P[i].y));
Y[P[i].y].insert(Data(i, P[i].x));
}
int t = solve(u);
ans = max(ans, t);
}
printf("%d\n", ans);
}
return 0;
}1697: Surface Area of Cubes
#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<cstdio>
#include<cctype>
#include<bitset>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define fuck(x) cout<<"["<<x<<"]"
#define FIN freopen("input.txt","r",stdin)
#define FOUT freopen("output.txt","w+",stdout)
//#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
typedef long long LL;
const int MX = 1e3 + 5;
struct Node {
int x, y, z;
Node() {}
Node(int _x, int _y, int _z) {
x = _x; y = _y; z = _z;
}
bool operator<(const Node &P) const {
if(x == P.x) {
if(y == P.y) return z < P.z;
return y < P.y;
}
return x < P.x;
}
};
LL A, B, C;
multiset<Node>S;
bool check(int x, int y, int z) {
if(x < 1 || x > A || y < 1 || y > B || z < 1 || z > C) return false;
if(S.count(Node(x, y, z))) return false;
return true;
}
int f(int x) {
if(x == 0) return -2;
if(x == 1) return 0;
return 2;
}
int main() {
int n; //FIN;
while(~scanf("%lld%lld%lld%d", &A, &B, &C, &n)) {
LL ans = 2 * A * B + 2 * A * C + 2 * B * C;
S.clear();
for(int i = 1; i <= n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
x++; y++; z++;
ans += f(check(x - 1, y, z) + check(x + 1, y, z));
ans += f(check(x, y - 1, z) + check(x, y + 1, z));
ans += f(check(x, y, z - 1) + check(x, y, z + 1));
S.insert(Node(x, y, z));
}
printf("%lld\n", ans);
}
return 0;
}1712: Refract Facts
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
#define PI 3.14159265358
int main()
{
double d, h, x,n1, n2;
while (scanf("%lf%lf%lf%lf%lf",&d,&h,&x,&n1,&n2))
{
if (d==0&&h==0&&x==0&&n1==0&&n2==0)
break;
double ans = 90;
double s = 0.0;
double j;
if (x == 0)
{
printf("90.00\n");
continue;
}
for(j=0.001;j<90;j+=0.001)
{
double xxx = j * PI / 180.0;
double y = d / tan(xxx);
if (x < y)
continue;
double yy = y * y;
double xx = yy * (h * h + ((x - y) * (x - y)));
double yyy = (yy + d * d) * (x - y) * (x - y);
double fff = (n1 * n1) / (n2 * n2) - xx/yyy;
if (fabs(fff-0.0) < ans)
{
ans = fabs(fff-0.0);
s = j;
//printf("%lf\n",s);
}
}
printf("%.2lf\n",s);
}
}1715: Positive Con Sequences
#include"iostream"
#include"cmath"
using namespace std;
#define eps 1e-6
int main(){
int i,j,a[5];
while(cin>>a[1]>>a[2]>>a[3]>>a[4]){
int sol;
if(a[1]==-1 && a[2]==-1 && a[3]==-1 && a[4]==-1){
break;
}
if(a[1]==0 || a[2]==0 || a[3]==0 || a[4]==0){
cout<<-1<<endl;
continue;
}
for(i=1; i<=4; i++){
if(a[i]==-1){
sol = i;//位置
}
}
if(sol==1){ //1 未知
a[0] = a[3]-a[2];
a[1] = a[2]-a[0];
if(a[1]+a[0] ==a[2] && a[1]+2*a[0]==a[3] && a[1]+3*a[0]==a[4]
&& a[1]<=10000 && a[1]>0){//差
cout<<a[1]<<endl;
continue;
}
a[0] = a[3]/a[2];
a[1] = a[2]/a[0];
if(a[1]*a[0] ==a[2] && a[1]*a[0]*a[0]==a[3] && a[1]*a[0]*a[0]*a[0]==a[4]
&& a[1]<=10000 && a[1]>0){ //比
cout<<a[1]<<endl;
continue;
}
cout<<-1<<endl;
}
if(sol==4){// 4未知
a[0] = a[3]-a[2];
a[4] = a[3]+a[0];
if(a[4]-a[0]==a[3] && a[4]-2*a[0]==a[2] && a[4]-3*a[0]==a[1]
&& a[4]<=10000 && a[4]>0 ){ //差
cout<<a[4]<<endl;
continue;
}
a[0] = a[3]/a[2];
a[4] = a[3]*a[0];
if(a[4]/a[0] ==a[3] && a[4]/a[0]/a[0]==a[2] && a[4]/a[0]/a[0]/a[0]==a[1]
&& a[4]<=10000 && a[4]>0 ){//比
cout<<a[4]<<endl;
continue;
}
cout<<-1<<endl;
}
if(sol==2){// 2 未知
a[0] = a[4]-a[3];
a[2] = a[1]+a[0];
if(a[2]+a[0] ==a[3] && a[2]+2*a[0]==a[4] && a[2]-a[0]==a[1]
&& a[2]<=10000 && a[2]>0){//差
cout<<a[2]<<endl;
continue;
}
a[0] = a[4]/a[3];
a[2] = a[1]*a[0];
if(a[2]*a[0] == a[3] && a[2]*a[0]*a[0]==a[4] && a[2]/a[0]==a[1]
&& a[2]<=10000 && a[2]>0 ){//比
cout<<a[2]<<endl;
continue;
}
cout<<-1<<endl;
}
if(sol==3){// 3 未知
a[0] = a[2]-a[1];
a[3] = a[2]+a[0];
if(a[3]-a[0]==a[2] && a[3]-2*a[0]==a[1] && a[3]+a[0]==a[4]
&& a[3]<=10000 && a[3]>0 ){//差
cout<<a[3]<<endl;
continue;
}
a[0] = a[2]/a[1];
a[3] = a[2]*a[0];
if(a[3]*a[0] ==a[4] && a[3]/a[0]==a[2] && a[3]/a[0]/a[0]==a[1]
&& a[3]<=10000 && a[3]>0 ){//比
cout<<a[3]<<endl;
continue;
}
cout<<-1<<endl;
}
}
return 0;
}
1718 And Then There Was 5
这题其实我不确定是什么情况，按照题目内容推理，应该是代码搜集之后忘了记在这里。
1720: How to Get 2^n
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")
using namespace std;
#define MAX 100005
//#define MAXN 500005
#define maxnode 105
#define sigma_size 2
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define lrt rt<<1
#define rrt rt<<1|1
#define middle int m=(r+l)>>1
#define LL long long
#define ull unsigned long long
#define mem(x,v) memset(x,v,sizeof(x))
#define lowbit(x) (x&-x)
#define pii pair<int,int>
#define bits(a) __builtin_popcount(a)
#define mk make_pair
#define limit 10000
//const int prime = 999983;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-9;
const LL mod = 1e9+7;
const ull mx = 1e9+7;
/*****************************************************/
inline void RI(int &x) {
char c;
while((c=getchar())<'0' || c>'9');
x=c-'0';
while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
}
/*****************************************************/
const int MX = 10;//一共可以表示长度MX*DLEN的
const int maxn = 9999;
const int DLEN = 4;//一个int里面放多少个数字
char ret[105];
class Big {
public:
int a[MX], len;
Big(const int b = 0) {
int c, d = b;
len = 0;
memset(a, 0, sizeof(a));
while(d > maxn) {
c = d - (d / (maxn + 1)) * (maxn + 1);
d = d / (maxn + 1);
a[len++] = c;
}
a[len++] = d;
}
Big(const char *s) {
int t, k, index, L, i;
memset(a, 0, sizeof(a));
L = strlen(s);
len = L / DLEN;
if(L % DLEN) len++;
index = 0;
for(i = L - 1; i >= 0; i -= DLEN) {
t = 0;
k = i - DLEN + 1;
if(k < 0) k = 0;
for(int j = k; j <= i; j++) {
t = t * 10 + s[j] - '0';
}
a[index++] = t;
}
}
Big operator/(const int &b)const {
Big ret;
int i, down = 0;
for(int i = len - 1; i >= 0; i--) {
ret.a[i] = (a[i] + down * (maxn + 1)) / b;
down = a[i] + down * (maxn + 1) - ret.a[i] * b;
}
ret.len = len;
while(ret.a[ret.len - 1] == 0 && ret.len > 1) ret.len--;
return ret;
}
bool operator>(const Big &T)const {
int ln;
if(len > T.len) return true;
else if(len == T.len) {
ln = len - 1;
while(a[ln] == T.a[ln] && ln >= 0) ln--;
if(ln >= 0 && a[ln] > T.a[ln]) return true;
else return false;
} else return false;
}
Big operator+(const Big &T)const {
Big t(*this);
int i, big;
big = T.len > len ? T.len : len;
for(i = 0; i < big; i++) {
t.a[i] += T.a[i];
if(t.a[i] > maxn) {
t.a[i + 1]++;
t.a[i] -= maxn + 1;
}
}
if(t.a[big] != 0) t.len = big + 1;
else t.len = big;
return t;
}
Big operator-(const Big &T)const {
int i, j, big;
bool flag;
Big t1, t2;
if(*this > T) {
t1 = *this;
t2 = T;
flag = 0;
} else {
t1 = T;
t2 = *this;
flag = 1;
}
big = t1.len;
for(i = 0; i < big; i++) {
if(t1.a[i] < t2.a[i]) {
j = i + 1;
while(t1.a[j] == 0) j++;
t1.a[j--]--;
while(j > i) t1.a[j--] += maxn;
t1.a[i] += maxn + 1 - t2.a[i];
} else t1.a[i] -= t2.a[i];
}
t1.len = big;
while(t1.a[t1.len - 1] == 0 && t1.len > 1) {
t1.len--;
big--;
}
if(flag) t1.a[big - 1] = 0 - t1.a[big - 1];
return t1;
}
int operator%(const int &b)const {
int i, d = 0;
for(int i = len - 1; i >= 0; i--) {
d = ((d * (maxn + 1)) % b + a[i]) % b;
}
return d;
}
Big operator*(const Big &T) const {
Big ret;
int i, j, up, temp, temp1;
for(i = 0; i < len; i++) {
up = 0;
for(j = 0; j < T.len; j++) {
temp = a[i] * T.a[j] + ret.a[i + j] + up;
if(temp > maxn) {
temp1 = temp - temp / (maxn + 1) * (maxn + 1);
up = temp / (maxn + 1);
ret.a[i + j] = temp1;
} else {
up = 0;
ret.a[i + j] = temp;
}
}
if(up != 0) {
ret.a[i + j] = up;
}
}
ret.len = i + j;
while(ret.a[ret.len - 1] == 0 && ret.len > 1) ret.len--;
return ret;
}
ull print() {
ull ret=0;
for(int i=len-1;i>=0;i--) ret=ret*mx+a[i];
return ret;
}
}pow2[105],ss;
map<ull,int> ma;
char s[105];
void init(){
pow2[0]=1;
for(int i=1;i<=103;i++) pow2[i]=pow2[i-1]*2;
}
int main(){
//freopen("test.txt","r",stdin);
int t;
cin>>t;
init();
while(t--){
int n;
cin>>n;
ma.clear();
LL ans=0;
for(int i=0;i<n;i++){
scanf("%s",s);
int len;
ss=s;
for(int j=103;j>=1;j--){
if(pow2[j]>ss){
Big cnt=pow2[j]-ss;
ull temp=cnt.print();
if(ma.count(temp)) ans+=ma[temp];
}
}
ull tmp=ss.print();
if(!ma.count(tmp)) ma[tmp]=0;
ma[tmp]++;
//cout<<ma[ss[i]]<<" "<<ss[i]<<endl;
}
cout<<ans<<endl;
}
return 0;
} 1721: 皇家火枪手
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
#define N int(2e3+10)
#define inf int(0x3f3f3f3f)
#define mod int(1e9+7)
typedef long long LL;
int main()
{
#ifdef OFFLINE
freopen("t.txt", "r", stdin);
#endif
LL t, n, m, a, k, num;
scanf("%lld", &t);
while (t--){
LL ans = 0, sum = 0;
scanf("%lld%lld%lld", &m, &a, &k);
if (k == 1){
ans += m / a;
if (m%a) ans++;
}
else{
num = k / 2;
sum = 2 * a * (num*(num + 1) / 2);//需要num人
if (sum >= m){
while (sum >= m){
sum -= 2 * a * num;
num--;
}
num++;//通过while找到确切的num
ans = num;
}
else{
if (k % 2 == 0){
ans = num;
m -= sum;
if (m > 0){//切记防止让负数参与
//还需加入的人数，这时加入的每个人贡献(2 * a*num)点攻击力
ans += m / (2 * a*num);
if (m % (2 * a*num)) ans++;
}
}
else{
ans = num;
sum += 2 * a*num + a;//加上留到最后一秒的人的攻击力
m -= sum;
ans++;
if (m > 0){
ans += m / (2 * a*num + a);
if (m % (2 * a*num + a)) ans++;
}
}
}
}
printf("%lld\n", ans);
}
return 0;
}1726: 你经历过绝望吗？两次！
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define EPS 1e-6
#define INF INT_MAX / 10
#define LL long long
#define MOD 100000000
#define PI acos(-1.0)
using namespace std;
struct node
{
int x,y;
int step;
};
bool operator < (node p,node q)
{
return p.step > q.step;
}
const int maxn = 111;
int n,m;
char maze[maxn][maxn];
int dir[4][2] = {{0,1},{-1,0},{0,-1},{1,0}};
int sx,sy;
int bfs()
{
priority_queue<node> que;
node p;
p.x = sx,p.y = sy,p.step = 0;
que.push(p);
maze[sx][sy] = '#';
while(que.size()){
node q = que.top();
que.pop();
if(q.x == n - 1 || q.y == m - 1 || q.x == 0 || q.y == 0){
return q.step;
}
for(int i = 0;i < 4;i++){
node r;
r.x = q.x + dir[i][0];
r.y = q.y + dir[i][1];
if(0 <= r.x && r.x < n && 0 <= r.y && r.y < m && maze[r.x][r.y] != '#'){
if(maze[r.x][r.y] == '*')
r.step = q.step + 1;
else
r.step = q.step;
que.push(r);
maze[r.x][r.y] = '#';
}
}
}
return -1;
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
scanf("%d %d",&n,&m);
for(int i = 0;i < n;i++)
scanf("%s",maze[i]);
for(int i = 0;i < n;i++){
for(int j = 0;j < m;j++){
if(maze[i][j] == '@'){
sx = i;
sy = j;
break;
}
}
}
printf("%d\n",bfs());
memset(maze,0,sizeof(maze));
}
return 0;
}1728: 线形逐步共聚合反应
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")
using namespace std;
#define MAX 200005
#define MAXN 500005
#define maxnode 105
#define sigma_size 2
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define lrt rt<<1
#define rrt rt<<1|1
#define middle int m=(r+l)>>1
#define LL long long
#define ull unsigned long long
#define mem(x,v) memset(x,v,sizeof(x))
#define lowbit(x) (x&-x)
#define pii pair<int,int>
#define bits(a) __builtin_popcount(a)
#define mk make_pair
#define limit 10000
//const int prime = 999983;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-9;
const LL mod = 1e9+7;
const ull mx = 1e9+7;
/*****************************************************/
inline void RI(int &x) {
char c;
while((c=getchar())<'0' || c>'9');
x=c-'0';
while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
}
/*****************************************************/
int a[MAX];
double dp[MAX],dp1[MAX];
int n;
double get(double x){
dp[0]=dp1[0]=0;
double ret=0;
for(int i=1;i<=n;i++){
dp[i]=max(dp[i-1]+(a[i]-x),(a[i]-x));
dp1[i]=max(dp1[i-1]+(x-a[i]),(x-a[i]));
ret=max(ret,dp[i]);
ret=max(ret,dp1[i]);
}
return ret;
}
int main(){
//freopen("test.txt","r",stdin);
int t;
cin>>t;
while(t--){
cin>>n;
int mini=INF,maxn=0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
mini=min(mini,a[i]);
maxn=max(maxn,a[i]);
}
double l=mini,r=maxn;
for(int i=0;i<100;i++){
double ll=(2*l+r)/3;
double rr=(2*r+l)/3;
if(get(ll)<get(rr)) r=rr;
else l=ll;
}
printf("%.6f\n",l);
}
return 0;
}1731: XueXX and P-P String
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <bitset>
#include <vector>
#include <cstdio>
#include <string>
#include <cassert>
#include <climits>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
typedef long long ll;
typedef unsigned long long ull;
#define fi first
#define se second
#define prN printf("\n")
#define SI(N) scanf("%d",&(N))
#define SII(N,M) scanf("%d%d",&(N),&(M))
#define SIII(N,M,K) scanf("%d%d%d",&(N),&(M),&(K))
#define cle(a,val) memset(a,(val),sizeof(a))
#define rep(i,b) for(int i=0;i<(b);i++)
#define Rep(i,a,b) for(int i=(a);i<=(b);i++)
string a;
int save[205];
int judge(int in1,int in2)
{
int len=in2-in1+1;
int fl=0;
if (len&1)
{
int mid=(in1+in2)/2;
int s=mid-1,e=mid+1;
while(a[s]==a[e]&&s>=in1&&e<=in2)
{
s--,e++;
}
if (s==in1-1&&e==in2+1)
return 1;
else return 0;
}
else
{
int mid=(in1+in2)/2;
int s=mid,e=mid+1;
while(a[s]==a[e]&&s>=in1&&e<=in2)
{
s--,e++;
}
if (s==in1-1&&e==in2+1)
return 1;
else return 0;
}
}
int main()
{
int o;
cin>>o;
while (o--)
{
cle(save,0);
cin>>a;
int len=a.size();
int ans=0;
for (int i=1; i<=len-2; i++)
{
for (int j=1; j<=len-3; j++)
{
if (i-j<0||i+2*j-1>=len)
break;
else
{
int a=i-j,b=i+j-1,c=i+2*j-1;
int f1=judge(a,b);
int f2=judge(i,c);
if (f1&&f2)
{
ans=max(3*j,ans);
}
}
}
}
printf("%d\n",ans);
}
return 0;
}1733: XueXX and Chessboard
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <bitset>
#include <vector>
#include <cstdio>
#include <string>
#include <cassert>
#include <climits>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF=-1;
typedef long long ll;
typedef unsigned long long ull;
#define fi first
#define se second
#define prN printf("\n")
#define SI(N) scanf("%d",&(N))
#define SII(N,M) scanf("%d%d",&(N),&(M))
#define SIII(N,M,K) scanf("%d%d%d",&(N),&(M),&(K))
#define cle(a,val) memset(a,(val),sizeof(a))
#define rep(i,b) for(int i=0;i<(b);i++)
#define Rep(i,a,b) for(int i=(a);i<=(b);i++)
int n,m,k;
int dp[1005][1005];
const int mod=1000000007;
int main()
{
int o;
cin>>o;
while(o--)
{
cle(dp,0);
cin>>n>>m>>k;
int x,y;
rep(i,k)
{
cin>>x>>y;
dp[x][y]=INF;
}
dp[0][1]=1;
Rep(i,1,n)
{
Rep(j,1,m)
{
if(dp[i][j]==INF)continue;
if (dp[i-1][j]>=0&&dp[i][j-1]>=0)
{
dp[i][j]+=(dp[i-1][j]+dp[i][j-1]);
dp[i][j]%=mod;
}
if (dp[i-1][j]==INF&&dp[i][j-1]==INF)
{
dp[i][j]+=0;
}
if (dp[i-1][j]>=0&&dp[i][j-1]==INF)
{
dp[i][j]+=dp[i-1][j];
dp[i][j]%=mod;
}
if (dp[i-1][j]==INF&&dp[i][j-1]>=0)
{
dp[i][j]+=dp[i][j-1];
dp[i][j]%=mod;
}
}
}
if (dp[n][m]==INF)
puts("0");
else
printf("%d\n",dp[n][m]);
}
return 0;
}1749: Soldiers ' Training
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
using namespace std;
const int N = 105;
int a[N],b[N];
int main(){
int n,k;
while(scanf("%d%d",&n,&k)!=EOF){
int sum = 0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
sum+=a[i];
}
int cnt = 0;
sort(a+1,a+1+n);
while(sum<n*k){
cnt++;
for(int i=1;i<=n;i++) b[i] = a[i];
if(a[1]<k){
b[1]++;
sum++;
}
for(int i=2;i<=n;i++){
if(a[i]==a[i-1]||a[i]==k) continue;
b[i]++;
sum++;
}
for(int i=1;i<=n;i++){
a[i] = b[i];
}
sort(a+1,a+1+n);
}
printf("%d\n",cnt);
}
}1765: 简单shell
#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
int n;
vector<vector<int> > vec;
vector<int> lujing;
char tc[15];
string ti;
int main()
{
int T,a,b;
cin>>T;
while (T--)
{
cin>>n;
lujing.clear();
lujing.push_back(1);
vec.clear();
vec.resize(n+3);
for (int i=1;i<n;i++)
{
cin>>a>>b;
vec[a].push_back(b);
}
while(cin>>tc&&tc[0]!='e')
{
if (tc[0]=='l')
{
if (vec[lujing[lujing.size()-1]].empty())
continue;
else
{
for (int i=0;i<(int)vec[lujing[lujing.size()-1]].size()-1;i++)
cout<<vec[lujing[lujing.size()-1]][i]<<' ';
cout<<vec[lujing[lujing.size()-1]][vec[lujing[lujing.size()-1]].size()-1]<<endl;
}
}
else if (tc[0]=='p')
{
if (lujing.empty())
continue;
else
{
for (int i=0;i<(int)lujing.size();i++)
cout<<'/'<<lujing[i];
cout<<endl;
}
}
else if (tc[0]=='c')
{
cin>>ti;
if (ti[0]=='.')
{
lujing.pop_back();
}
else
{
stringstream ss;
ss<<ti;
int temp;
ss>>temp;
lujing.push_back(temp);
}
}
}
}
return 0;
}1772: 漫漫上学路
#include <cstdio>
#include <cstring>
typedef long long ll;
const int maxn = 31;
ll d[maxn];
void catalan()
{
int i,j;
d[0] = 1;
for(i = 1;i < maxn;i++){
d[i] = 0;
for(j = 0;j < i;j++){
d[i] += d[j] * d[i - j - 1];
}
}
}
int main()
{
int n,i, j;
catalan();
while(scanf("%d",&n) != EOF && 1 <= n && n <= 30){
printf("%lld\n",d[n]);
}
return 0;
}1774: 慷慨的奖励
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 5;
int N, D;
char str[maxn];
struct Node {
int prior, rear;
} nodes[maxn];
void del(int x) {
int a = nodes[x].prior;
int b = nodes[x].rear;
if(a == -1) {
nodes[b].prior = -1;
} else {
nodes[a].rear = b;
}
if(b == -1) {
nodes[a].rear = -1;
} else {
nodes[b].prior = a;
}
}
int main() {
while(~scanf("%d %d", &N, &D) && N) {
scanf("%s", str);
nodes[0].prior = -1;
nodes[0].rear = 1;
nodes[N - 1].prior = N - 2;
nodes[N - 1].rear = -1;
for(int i = 1; i < N - 1; i++) {
nodes[i].prior = i - 1;
nodes[i].rear = i + 1;
}
int pos = 0, phead = 0, cnt = D;
while(cnt > 0) {
int np = nodes[pos].rear;
if(np != -1 && str[pos] < str[np]) {
del(pos);
if(pos == phead) phead = np;
pos = np;
cnt --;
} else if(np != -1 && str[pos] >= str[np]) {
pos ++;
continue;
} else if(np == -1) {
pos = nodes[pos].prior;
del(nodes[pos].rear);
cnt --;
}
int pp = nodes[pos].prior;
while(cnt > 0 && pp != -1 && str[pos] > str[pp]) {
del(pp);
pp = nodes[pos].prior;
cnt --;
}
if(pp == -1) phead = pos;
}
for(int i = 0, pos = phead; i < N - D; i ++) {
printf("%c", str[pos]);
pos = nodes[pos].rear;
}
puts("");
}
return 0;
}1780: 简单的图论问题?
#include<string>
#include<math.h>
#include<stdio.h>
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
#include<string.h>
#include <stdlib.h>
#include<iterator>
using namespace std;
typedef unsigned long long ll;
const int maxn = 505;
const int inf = 100000;
int vis1[maxn][maxn];
int vis2[maxn][maxn][4];
int a[maxn][maxn];
int n,m,r1,r2,c1,c2;
struct node{
int x,y,dir;
int step;
};
bool operator<(node a , node b){
return a.step > b.step;
}
int to[4][2] = {1,0,-1,0,0,1,0,-1};
int bfs1(){
if(c1 == c2&& r1 == r2)
return 0;
priority_queue<struct node> que;
memset(vis1,0,sizeof(vis1));
node no,nxt,now;
no.x = r1 ; no.y = c1 ; no.step = a[r1][c1];
que.push(no);
vis1[r1][c1] = 1;
while(!que.empty()){
now = que.top();
que.pop();
if(now.x == r2&&now.y == c2)
return now.step;
for(int i = 0 ; i < 4; i ++){
nxt.x = now.x + to[i][0];
nxt.y = now.y + to[i][1];
if(nxt.x>0&&nxt.x<=n&&nxt.y>0&&nxt.y<=m&&a[nxt.x][nxt.y]!=0&&!vis1[nxt.x][nxt.y]){
vis1[nxt.x][nxt.y] = 1;
nxt.step = now.step + a[nxt.x][nxt.y];
que.push(nxt);
}
}
}
return -1;
}
int bfs2(){
if(c1 == c2&& r1 == r2)
return 0;
priority_queue<struct node> que;
memset(vis2,0,sizeof(vis2));
node no,nxt,now;
no.x = r1 ; no.y = c1 ; no.step = a[r1][c1];
no.dir = -1;
que.push(no);
vis2[r1][c1][0] = vis2[r1][c1][1] = vis2[r1][c1][2] =vis2[r1][c1][3] = 1;
while(!que.empty()){
now = que.top();
que.pop();
if(now.x == r2&&now.y == c2)
return now.step;
for(int i = 0 ; i < 4; i ++){
nxt.x = now.x + to[i][0];
nxt.y = now.y + to[i][1];
if(now.dir==i)
continue;
if(nxt.x>0&&nxt.x<=n&&nxt.y>0&&nxt.y<=m&&a[nxt.x][nxt.y]!=0&&!vis2[nxt.x][nxt.y][i]){
vis2[nxt.x][nxt.y][i] = 1;
nxt.step = now.step + a[nxt.x][nxt.y];
nxt.dir = i;
que.push(nxt);
}
}
}
return -1;
}
int main()
{
int i,j;
char ch[5];
int k = 1;
while(~scanf("%d%d%d%d%d%d",&n,&m,&r1,&c1,&r2,&c2)){
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
cin>>ch;
if(ch[0] == '*')
a[i][j] = 0;
else
a[i][j] = atoi(ch);
}
}
cout<<"Case "<<k++<<": ";
int res1 = bfs1();
int res2 = bfs2();
printf("%d %d\n",res1,res2);
}
return 0;
}1784: Internet of Lights and Switches
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
typedef long long LL;
char str[80];
const int INF = 999999999;
map<LL,vector<int> > mp;
int n,m,A,B;
LL charToLL(char *str){
LL ans = 0;
int p = 1,len = strlen(str);
for(int i=len-1;i>=0;i--){
if(str[i]=='1'){
ans+=p;
}
p*=2;
}
return ans;
}
int binary(LL val,int id){
vector <int> vec = mp[val];
int down = 0,up = vec.size()-1,r=-1,l=INF;
while(down<=up){
int mid = (down+up)>>1;
if(id-vec[mid]>=A){
r = mid;
down = mid+1;
}else up = mid-1;
}
down = 0,up = vec.size()-1;
while(down<=up){
int mid = (down+up)>>1;
if(id-vec[mid]<=B){
l = mid;
up = mid-1;
}else down = mid+1;
}
//printf("%d %d\n",l,r);
if(l>r) return 0;
return r-l+1;
}
int main(){
int t = 1;
while(scanf("%d%d%d%d",&m,&n,&A,&B)!=EOF){
mp.clear();
for(int i=0;i<m;i++){
str[i] = '1';
}
str[m]='\0';
LL k = charToLL(str),xorsum=0,ans = 0;
for(int i=1;i<=n;i++){
scanf("%s",str);
LL x = charToLL(str);
xorsum^=x;
if(xorsum==k&&i>=A&&i<=B) ans++;
ans+=binary(k^xorsum,i);
mp[xorsum].push_back(i);
}
printf("Case %d: %lld\n",t++,ans);
}
}1797: Train passengers
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 200005
#define mod 360000
const int INF = 0x3f3f3f3f;
#define exp 1e-6
int main()
{
LL C,n,sum,w,a,b,c;
w(scanf("%lld%lld",&C,&n)>0)
{
sum=0;
w=0;
int flag=0;
w(n--)
{
scanf("%lld%lld%lld",&a,&b,&c);
if(flag)
continue;
if(sum<a)
{
flag=1;
continue;
}
sum=sum-a+b;
if(sum>C)
flag=1;
if(sum!=C && c) flag = 1;
if(!n && (sum || b || c)) flag = 1;
}
if(flag)
printf("impossible\n");
else
printf("possible\n");
}
}1801: Mr. S’s Romance
#include <stdio.h>
#include <string.h>
#include <iostream>
#define MAXN 1000005
using namespace std;
typedef long long LL;
bool isprime[MAXN];
int prime[MAXN];
int indexnum[MAXN];
int num;
const int TOP=80000;
const LL MOD=1000000000LL+7;
int get_prime()
{
memset(isprime,true,sizeof(isprime));
isprime[1]=false;
for(int i=2;i*i<MAXN-4;i++)
if(isprime[i])
for(int j=2;i*j<MAXN-4;j++)
isprime[i*j]=false;
num=0;
for(int i=1;i<MAXN-4;i++)
if(isprime[i])
indexnum[i]=num,prime[num++]=i;
return num;
}
int a[TOP];
void deal(int x)
{
for(int i=0;i<num;i++){
if(isprime[x]){
a[indexnum[x]]++;
break;
}
while(x%prime[i]==0){
a[i]++;
x/=prime[i];
}
if(x==1)
break;
}
}
LL mul(LL x,LL n,LL mod)
{
LL tmp=x;
LL ans=1;
while(n){
if(n&1){
ans*=tmp;
ans%=mod;
}
tmp*=tmp;
tmp%=mod;
n>>=1;
}
return ans%mod;
}
int main()
{
//freopen("in.data","r",stdin);
get_prime();
int T,K=1;
for(cin>>T;T--;){
int n;
scanf("%d",&n);
memset(a,0,sizeof(a));
for(int i=0;i<n;i++){
int tmp;
scanf("%d",&tmp);
deal(tmp);
}
LL ans=1;
for(int i=0;i<num;i++)
if(a[i])
ans=ans*mul(2,a[i]-1,MOD)%MOD;
ans=(ans-1+MOD)%MOD;
printf("Case #%d:\n%lld\n",K++,ans);
}
return 0;
}1802: 小X的战斗力
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 0x3f3f3f3f
using namespace std;
int n,m;
int map[200][200];
int main()
{
int test;
scanf("%d",&test);
while(test--)
{
memset(map,0,sizeof(map));
int a,b;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a,&b);//a赢b
map[b][a]=1;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
for(int k=1;k<=n;k++)
{
if(map[j][i]==1&&map[i][k]==1)
{
map[j][k]=1;
}
}
}
}
int flag=0;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(map[j][i]==1&&map[i][j]==1)
{
flag=1;
break;
}
}
if(flag==1)break;
}
if(flag==1)
{
printf("Wrong\n");
continue;
}
int num=0;
int is_sure1=1;
for(int i=1;i<=n;i++)//判断i号点是不是确定的
{
int is_sure=1;
for(int j=1;j<=n;j++)
{
if(i==j)continue;
if(map[i][j]==0&&map[j][i]==0)
{
is_sure=0;
break;
}
}
if(is_sure==1)num++;
}
int rank=1;
for(int i=2;i<=n;i++)
{
if(map[1][i]==1)
{
rank++;
continue;
}
if(map[i][1]==0)
{
is_sure1=0;
break;
}
}
if(is_sure1==0) printf("-1\n");
else printf("%d\n",rank);
printf("%d\n",num);
}
}1804: 有向无环图
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int mo=1e9+7;
const int maxn=1e5+10;
int head[maxn],e[2*maxn],nex[2*maxn];
int a[maxn],b[maxn],vis[maxn],f[maxn];
int ans,tot;
void add_edge(int u,int v){
e[tot]=v;nex[tot]=head[u];head[u]=tot++;
}
void dfs(int u){
int v,i;
f[u]=0;vis[u]=1;
if (head[u]==-1) {
f[u]=b[u];
return;
}
for (i=head[u];i!=-1;i=nex[i]){
v=e[i];
if (!vis[v]) dfs(v);
f[u]=(f[u]+f[v])%mo;
}
ans=(ans+(long long)f[u]*a[u]%mo)%mo;
f[u]=(f[u]+b[u])%mo;
}
int main()
{
int i,n,m,u,v;
while (scanf("%d %d",&n,&m)!=-1){
for (i=1;i<=n;i++) head[i]=-1;
tot=0;
for (i=1;i<=n;i++){
scanf("%d %d",&a[i],&b[i]);
}
for (i=1;i<=m;i++){
scanf("%d %d",&u,&v);
add_edge(u,v);
}
memset(vis,0,sizeof(vis));
ans=0;
for (i=1;i<=n;i++){
if (!vis[i]) dfs(i);
}
printf("%d\n",ans);
}
return 0;
}1805: Three Capitals
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")
using namespace std;
#define MAX 100010
#define MAXN 1000005
#define maxnode 5
#define sigma_size 30
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define lrt rt<<1
#define rrt rt<<1|1
#define middle int m=(r+l)>>1
#define LL long long
#define ull unsigned long long
#define mem(x,v) memset(x,v,sizeof(x))
#define lowbit(x) (x&-x)
#define pii pair<int,int>
#define bits(a) __builtin_popcount(a)
#define mk make_pair
#define limit 10000
//const int prime = 999983;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const LL mod = 1e9+7;
const ull mx = 133333331;
/*****************************************************/
inline void RI(int &x) {
char c;
while((c=getchar())<'0' || c>'9');
x=c-'0';
while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
}
/*****************************************************/
bool isFreeX[5];
LL A[5][5];
LL atob,atoc,btoa,btoc,ctob,ctoa;
LL gauss(int n, int m) {//求行列式
for(int i = 0; i < m; ++i) isFreeX[i] = false;
LL ret = 1, neg = 0;
int r = 1, c = 1;//求n-1阶的行列式，去掉第一阶，所以从1开始
for(; r < n && c < m; ++r, ++c) {
int p = r;
for(; p < n; ++p) if(A[p][c]) break;
if(p == n) {--r; isFreeX[c] = true; continue;}
if(p != r) {
neg ^= 1;
for(int i = c; i <= m; ++i) swap(A[p][i], A[r][i]);
}
//eliminate coefficient
for(int i = r + 1; i < n; ++i) {
while(A[i][c]) {
LL delta = A[i][c] / A[r][c];
for(int j = c; j <= m; ++j) {
A[i][j] += mod - delta * A[r][j] % mod;
A[i][j] %= mod;
}
if(!A[i][c]) break;
neg ^= 1;
for(int j = c; j <= m; ++j) swap(A[r][j], A[i][j]);
}
}
}
if(r != n) return 0;
//0-r-1求n阶行列式，1-r-1求n-1阶行列式
for(int i = 1; i < r; ++i) ret = ret * A[i][i] % mod;
if(neg) ret = (-ret + mod) % mod;
return ret;
}
int deg[5];
LL fact[MAX];
void init(){
fact[0]=1;
for(int i=1;i<=100000;i++) fact[i]=fact[i-1]*i%mod;
}
LL qpow(LL a,LL n){
LL ans=1;
while(n){
if(n&1) ans=ans*a%mod;
a=a*a%mod;
n>>=1;
}
return ans;
}
LL C(int n,int m){
return (fact[n]*qpow(fact[m],mod-2)%mod)*qpow(fact[n-m],mod-2)%mod;
}
int main()
{
int a,b,c;
init();
while(cin>>a>>b>>c){
LL ans=0;
LL aa=a+b,bb=a+c,cc=c+b;
if(aa%2||bb%2||cc%2){
puts("0");continue;
}
for(int x=0;x<=a;x++)
{
atob=x;btoa=a-x;
btoc=bb/2-btoa;atoc=aa/2-x;
ctob=c-btoc;ctoa=b-atoc;
if(atoc<0||atob<0||btoa<0||btoc<0||ctoa<0||ctob<0) continue;
deg[0]=aa/2;
deg[1]=bb/2;
deg[2]=cc/2;
for(int i=0;i<3;i++) A[i][i]=deg[i];
A[0][1]=atob;A[0][2]=atoc;
A[1][0]=btoa;A[1][2]=btoc;
A[2][0]=ctoa;A[2][1]=ctob;
LL ret=(C(a,x)*C(b,atoc)%mod)*C(c,btoc)%mod;
ret=ret*gauss(3,3)%mod;
for(int i=0;i<3;i++) ret=ret*fact[deg[i]-1]%mod;
ret=ret*deg[0]%mod;
ans+=ret;
if(ans>=mod) ans-=mod;
}
cout<<ans<<endl;
}
return 0;
}1806: Toll
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <vector>
#include <set>
#include <bitset>
#include <stack>
#include <map>
#include <climits>
#include <functional>
using namespace std;
#define LL long long
const int INF=0x3f3f3f3f;
const double eps=1e-8;
int n,m,t;
int s[20],nt[200],e[200],c[200],d[200],cnt;
int visit[20];
double dis[20];
double SPFA(double x)
{
for(int i=0;i<=n;i++) dis[i]=1.0*INF;
memset(visit,0,sizeof visit);
queue<int>q;
visit[1]=1;
q.push(1);
dis[1]=0;
while(!q.empty())
{
int pre=q.front();
q.pop();
visit[pre]=0;
for(int i=s[pre];~i;i=nt[i])
{
if(dis[pre]+c[i]*x+d[i]<dis[e[i]])
{
dis[e[i]]=dis[pre]+c[i]*x+d[i];
if(!visit[e[i]])
{
visit[e[i]]=1;
q.push(e[i]);
}
}
}
}
return dis[n];
}
double get(double L,double R)
{
return (R-L)*(SPFA(L)+4*SPFA((L+R)/2)+SPFA(R))/6;
}
double Ans(double L,double R)
{
double mid=(L+R)/2;
double s0=get(L,R),s1=get(L,mid),s2=get(mid,R);
if(fabs(s0-(s1+s2))<=eps) return s0;
else return Ans(L,mid)+Ans(mid,R);
}
int main()
{
while(~scanf("%d%d%d",&n,&m,&t))
{
memset(s,-1,sizeof s);
cnt=1;
for(int i=1;i<=m;i++)
{
int u,v,cc,dd;
scanf("%d%d%d%d",&u,&v,&cc,&dd);
nt[cnt]=s[u],e[cnt]=v,c[cnt]=cc,d[cnt]=dd,s[u]=cnt++;
}
printf("%.8lf\n",Ans(0,1.0*t)/t);
}
return 0;
}1807: 最长上升子序列~
#include<set>
#include<map>
#include<ctime>
#include<cmath>
#include<stack>
#include<queue>
#include<bitset>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define rep(i,j,k) for (int i = j; i <= k; i++)
#define per(i,j,k) for (int i = j; i >= k; i--)
#define loop(i,j,k) for (int i = j;i != -1; i = k[i])
#define lson x << 1, l, mid
#define rson x << 1 | 1, mid + 1, r
#define ff first
#define ss second
#define mp(i,j) make_pair(i,j)
#define pb push_back
#define pii pair<int,int>
#define in(x) scanf("%d", &x);
using namespace std;
typedef long long LL;
const int low(int x) { return x&-x; }
const double eps = 1e-8;
const int INF = 0x7FFFFFFF;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
int n, a[N];
LL dp[N];
void init()
{
dp[0] = dp[1] = 0; rep(i, 2, N - 1) dp[i] = dp[i - 1] + 2 * i - 3;
}
int check(int x)
{
int now = 1;
rep(i, 1, n)
{
if (now == a[x]) ++now;
if (i == x) continue;
if (a[i] && a[i] != now) return 0;
++now;
}
return 1;
}
int check(int x, int y)
{
if (x != y - 1) return 0;
rep(i, 1, n)
{
if (i == x || i == y) continue;
if (a[i] && a[i] != i) return 0;
}
return 1;
}
LL get(int x, int y)
{
int l = n + 1, r = 0;
rep(i, 1, n) if (a[i] && a[i] != i) l = min(l, i), r = max(r, i);
rep(i, l, r) if (a[i] && a[i] == i) return 0;
int L = l, R = n - r + 1;
per(i, l, 1) if (a[i] == i) { L = l - i; break; }
rep(i, r, n) if (a[i] == i) { R = i - r; break; }
return 1LL * (L - x) * (R - y);
}
LL get()
{
LL res = 0, now = 0;
rep(i, 1, n) if (a[i]) res += dp[a[i] - now - 1], now = a[i];
return res + dp[n - now];
}
int main()
{
init();
while (scanf("%d", &n) != EOF)
{
int flag = 0, l = 0, r = 0;
rep(i, 1, n)
{
scanf("%d", &a[i]);
if (!a[i]) continue;
if (abs(a[i] - i) > 1) flag = i;
if (a[i] - i == 1) l = i;
if (i - a[i] == 1) r = i;
}
if (flag) { printf("%d\n", check(flag)); continue; }
if (l&&r) { printf("%d\n", check(l, r)); continue; }
if (l || r) { printf("%lld\n", get(!l, !r)); continue; }
printf("%lld\n", get());
}
return 0;
}1808: 地铁
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn =255555;
const int INF = 0x3f3f3f3f;
int n,m;
struct Edge{
int to,next;
int w;
}edge[maxn*2];
int head[maxn],tot;
void init(){
memset(head,-1,sizeof(head));
tot=0;
}
void addedge(int u,int v,int w){
edge[tot].to=v;
edge[tot].next = head[u];
edge[tot].w =w;
head[u]=tot++;
}
vector<int>num[maxn];
map<int,int>mp[maxn];
int dis[maxn];
int cnt;
struct node{
int now;
int c;
node(int _now = 0,int _c=0):now(_now),c(_c){}
bool operator <(const node &r)const
{
return c>r.c;
}
};
void DJ(){
priority_queue<node> que;
while(!que.empty()) que.pop();
for(int i=1;i<cnt;++i) dis[i]=INF;
for(int i=0;i<num[1].size();++i){
int st;
st = mp[1][num[1][i]];
dis[st]=0;
que.push(node(st,0));
}
node temp;
while(!que.empty()){
temp = que.top();
que.pop();
int u = temp.now;
int cost = temp.c;
if(cost>dis[u])
continue;
for(int i=head[u];~i;i=edge[i].next){
int v = edge[i].to;
int w = edge[i].w;
if(dis[v]>cost+w){
dis[v]= cost + w;
que.push(node(v,dis[v]));
}
}
}
}
int main(){
int u,v,w,x;
while(scanf("%d%d",&n,&m)!=EOF){
init();
cnt=1;
for(int i=1;i<=n;i++){
num[i].clear();
mp[i].clear();
}
for(int i=0;i<m;++i){
scanf("%d%d%d%d",&u,&v,&x,&w);
if(!mp[u][x]){
mp[u][x]=cnt++;
num[u].push_back(x);
}
u=mp[u][x];
if(!mp[v][x]){
mp[v][x]=cnt++;
num[v].push_back(x);
}
v=mp[v][x];
addedge(u,v,w);
addedge(v,u,w);
}
for(int i=1;i<=n;i++){
sort(num[i].begin(),num[i].end());
for(int j=0;j<num[i].size()-1;++j){
u=mp[i][num[i][j]];
v=mp[i][num[i][j+1]];
w=num[i][j+1]-num[i][j]; //同一站点不同线路的拆点之间的差值
addedge(u,v,w);
addedge(v,u,w);
}
}
DJ();
int ans=INF;
for(int i=0;i<num[n].size();i++){
u=mp[n][num[n][i]];
ans=min(ans,dis[u]);
}
printf("%d\n",ans);
}
return 0;
}1809: Parenthesis
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
#define lld %I64d
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scanl(d) scanf("%I64d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define scannl(n,m) scanf("%I64d%I64d",&n,&m)
#define mst(a,k) memset(a,k,sizeof(a))
#define LL long long
#define N 1005
#define mod 1000000007
inline int read(){int s=0;char ch=getchar();for(; ch<'0'||ch>'9'; ch=getchar());for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';return s;}
char s[100005];
int sum[100005];
struct node
{
int l,r,val;
}seg[100005*4];
void build(int i,int l,int r)
{
seg[i].l=l;
seg[i].r=r;
if(l==r)
{
seg[i].val = sum[l];
return ;
}
int mid = (l+r)>>1;
build(i<<1,l,mid);
build(i<<1|1,mid+1,r);
seg[i].val = min(seg[i<<1].val,seg[i<<1|1].val);
}
int query(int i,int l,int r)
{
if(l<=seg[i].l && r>=seg[i].r)
{
return seg[i].val;
}
int ret = 1e9;
int mid = (seg[i].l+seg[i].r)>>1;
if(mid>=l) ret = min(ret,query(i<<1,l,r));
if(mid<r) ret = min(ret,query(i<<1|1,l,r));
return ret;
}
int main()
{
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int n,q;
while(~scann(n,q))
{
scanf("%s",s+1);
mst(sum,0);
REPP(i,1,n)
if(s[i]=='(') sum[i] = sum[i-1] + 1;
else sum[i] = sum[i-1] - 1;
build(1,1,n);
while(q--)
{
int l,r;
scann(l,r);
if(l>r) swap(l,r);
if(s[l] == s[r] || s[l]==')')
puts("Yes");
else if(l==1 || r==n)
puts("No");
else
{
int ret = query(1,l,r-1);
if(ret<2) puts("No");
else puts("Yes");
}
}
}
return 0;
}1811: Tree Intersection
#include<set>
#include<map>
#include<ctime>
#include<cmath>
#include<stack>
#include<queue>
#include<bitset>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define rep(i,j,k) for (int i = j; i <= k; i++)
#define per(i,j,k) for (int i = j; i >= k; i--)
#define loop(i,j,k) for (int i = j;i != -1; i = k[i])
#define lson x << 1, l, mid
#define rson x << 1 | 1, mid + 1, r
#define ff first
#define ss second
#define mp(i,j) make_pair(i,j)
#define pb push_back
#define pii pair<int,LL>
#define in(x) scanf("%d", &x);
using namespace std;
typedef long long LL;
const int low(int x) { return x&-x; }
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
int n, col[N], x, y;
int ft[N], nt[N], u[N], v[N], sz;
int Ft[N], Nt[N], U[N], V[N], Sz;
int d[N], t, pre[N], L[N], R[N];
int f[N], ans[N];
void dfs(int x, int fa)
{
d[pre[x] = ++t] = x;
L[col[x]] = min(L[col[x]], t);
R[col[x]] = max(R[col[x]], t);
loop(i, ft[x], nt)
{
if (u[i] == fa) continue;
dfs(u[i], x);
U[Sz] = pre[u[i]]; V[Sz] = v[i];
Nt[Sz] = Ft[t]; Ft[t] = Sz++;
}
}
void add(int x, int y)
{
for (int i = x; i <= n; i += low(i)) f[i] += y;
}
int get(int x)
{
int res = 0;
for (int i = x; i; i -= low(i)) res += f[i];
return res;
}
int main()
{
while (scanf("%d", &n) != EOF)
{
Sz = sz = t = 0;
rep(i, 1, n) in(col[i]);
rep(i, 1, n) Ft[i] = ft[i] = -1;
rep(i, 1, n) L[i] = n + 1, R[i] = f[i] = 0;
rep(i, 1, n - 1)
{
in(x); in(y);
u[sz] = y; v[sz] = i; nt[sz] = ft[x]; ft[x] = sz++;
u[sz] = x; v[sz] = i; nt[sz] = ft[y]; ft[y] = sz++;
}
dfs(1, 0);
rep(i, 1, n) pre[i] = f[i] = 0;
rep(i, 1, n)
{
add(pre[col[d[i]]] + 1, 1); add(i + 1, -1); pre[col[d[i]]] = i;
if (i == R[col[d[i]]]) add(1, -1), add(L[col[d[i]]] + 1, 1);
loop(j, Ft[i], Nt) ans[V[j]] = get(U[j]);
}
rep(i, 1, n - 1) printf("%d\n", ans[i]);
}
return 0;
}1812: 三角形和矩形
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#define eps 1e-8
using namespace std;
struct point{
double x,y;
}S[5],J[5],I[110];
struct Node{
point a,b;
}A[5];
int sig(double n){
if(fabs(n)<eps)return 0;
else if(n>eps)return 1;
else return -1;
}
bool judge(int a,int b){//判断线段相交
if(min(A[a].a.x,A[a].b.x)>max(A[b].a.x,A[b].b.x)||min(A[a].a.y,A[a].b.y)>max(A[b].a.y,A[b].b.y)||min(A[b].a.x,A[b].b.x)>max(A[a].a.x,A[a].b.x)||min(A[b].a.y,A[b].b.y)>max(A[a].a.y,A[a].b.y))
return false;
double h,i,j,k;
h=(A[a].b.x-A[a].a.x)*(A[b].a.y-A[a].a.y)-(A[a].b.y-A[a].a.y)*(A[b].a.x-A[a].a.x);
i=(A[a].b.x-A[a].a.x)*(A[b].b.y-A[a].a.y)-(A[a].b.y-A[a].a.y)*(A[b].b.x-A[a].a.x);
j=(A[b].b.x-A[b].a.x)*(A[a].a.y-A[b].a.y)-(A[b].b.y-A[b].a.y)*(A[a].a.x-A[b].a.x);
k=(A[b].b.x-A[b].a.x)*(A[a].b.y-A[b].a.y)-(A[b].b.y-A[b].a.y)*(A[a].b.x-A[b].a.x);
return h*i<=eps&&j*k<=eps;
}
void getinter(point p1,point p2,point p3,point p4,point &inter){//求交点
inter=p1;
double ans=((p1.x-p3.x)*(p3.y-p4.y)-(p1.y-p3.y)*(p3.x-p4.x))/((p1.x-p2.x)*(p3.y-p4.y)-(p1.y-p2.y)*(p3.x-p4.x));
inter.x+=(p2.x-p1.x)*ans;
inter.y+=(p2.y-p1.y)*ans;
}
double dist(point p1,point p2){
return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
}
double cp(point p1,point p2,point p3){
return (p3.x-p1.x)*(p2.y-p1.y)-(p3.y-p1.y)*(p2.x-p1.x);
}
bool cmp(point a,point b){
double ans=cp(I[0],a,b);
if(sig(ans)==0){
return dist(I[0],a)-dist(I[0],b)<=0;
}
else return ans>0;
}
int main()
{
double x1,y1,x2,y2,x3,y3,x4,y4;
while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4)!=EOF){
S[0].x=x1;S[0].y=y1;S[1].x=x1;S[1].y=y2;S[2].x=x2;S[2].y=y1;
J[0].x=x3;J[0].y=y3;J[1].x=x3;J[1].y=y4;J[2].x=x4;J[2].y=y4;J[3].x=x4;J[3].y=y3;
int cnt=0;
for(int i=0;i<3;++i){//矩形中包含的三角形的点
if(S[i].x>=min(x3,x4)&&S[i].x<=max(x3,x4)&&S[i].y>=min(y3,y4)&&S[i].y<=max(y3,y4)){
I[cnt].x=S[i].x;I[cnt].y=S[i].y;cnt++;
}
}
for(int i=0;i<4;++i){//三角形中包含的矩形中的点
if(J[i].x>=min(x1,x2)&&J[i].x<=max(x1,x2)&&J[i].y>=min(y1,y2)&&J[i].y<=max(y1,y2)){
double k=(y1-y2)/(x2-x1);double b=y1-k*x2;
if((sig(k*x1-y1+b)>=0&&sig(J[i].x*k-J[i].y+b)>=0)||(sig(k*x1-y1+b)<=0&&sig(J[i].x*k-J[i].y+b)<=0)){
I[cnt].x=J[i].x;I[cnt].y=J[i].y;cnt++;
}
}
}
for(int i=0;i<3;++i){
for(int j=0;j<4;++j){//求出三角形和矩形的线段的交点
A[0].a=S[i];A[0].b=S[(i+1)%3];A[1].a=J[j];A[1].b=J[(j+1)%4];
//printf("%lf %lf %lf %lf\n",J[j].x,J[j].y,J[(j+1)%4].x,J[(j+1)%4].y);
if(judge(0,1)){
if(A[0].a.x==A[0].b.x&&A[0].a.x==A[1].a.x&&A[1].a.x==A[1].b.x)continue;
if(A[0].a.y==A[0].b.y&&A[0].a.y==A[1].a.y&&A[1].a.y==A[1].b.y)continue;
//printf("%lf %lf %lf %lf %lf %lf %lf %lf\n",A[0].a.x,A[0].a.y,A[0].b.x,A[0].b.y,A[1].a.x,A[1].a.y,A[1].b.x,A[1].b.y);
getinter(A[0].a,A[0].b,A[1].a,A[1].b,I[cnt]);cnt++;
// printf("%lf %lf\n",I[cnt-1].x,I[cnt-1].y);
}
}
}
// printf("%d\n",cnt);
if(cnt<2){
printf("0.00000000\n");
}
else {
int pos=0;
for(int i=0;i<cnt;++i){
if(I[pos].y>=I[i].y){
if(I[pos].y==I[i].y){
if(I[pos].x>I[i].x)pos=i;
}
else pos=i;
}
}
point temp=I[pos];I[pos]=I[0];I[0]=temp;
sort(I+1,I+cnt,cmp);//极角排序
double ans=0;
for(int i=0;i<cnt;++i){//求多边形面积
double area=(I[(i+1)%cnt].x*I[i].y-I[(i+1)%cnt].y*I[i].x)/2.0;
ans+=area;
}
printf("%.9lf\n",fabs(ans));
}
}
return 0;
}1813: 盖房子
#include<set>
#include<map>
#include<ctime>
#include<cmath>
#include<stack>
#include<queue>
#include<bitset>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define rep(i,j,k) for (int i = j; i <= k; i++)
#define per(i,j,k) for (int i = j; i >= k; i--)
#define loop(i,j,k) for (int i = j;i != -1; i = k[i])
#define lson x << 1, l, mid
#define rson x << 1 | 1, mid + 1, r
#define ff first
#define ss second
#define mp(i,j) make_pair(i,j)
#define pb push_back
#define pii pair<int,int>
#define in(x) scanf("%d", &x);
using namespace std;
typedef long long LL;
const int low(int x) { return x&-x; }
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const int mod = 1e9 + 7;
const int N = 1e3 + 10;
char s[N];
int n, m;
int c[N][N], a[N][N];
LL ls[N][N], lx[N][N], rs[N][N], rx[N][N];
void GetFour()
{
memset(c, 0, sizeof(c));
rep(i, 1, n)
{
rep(j, 1, m)
{
if (a[i][j] || c[i][j]) continue;
while (c[i][j] <= n - i && !a[i + c[i][j]][j]) c[i][j]++;
rep(k, 2, c[i][j]) c[i + k - 1][j] = c[i][j] - k + 1;
}
int sum = 0; stack<pii> p;
per(j, m, 1)
{
pii now = mp(c[i][j], 1);
while (!p.empty() && p.top().ff > now.ff)
{
pii q = p.top(); sum -= q.ff * q.ss;
now.ss += q.ss; p.pop();
}
sum += now.ff * now.ss;
p.push(now);
ls[i][j] = sum;
}
sum = 0; while (!p.empty()) p.pop();
rep(j, 1, m)
{
pii now = mp(c[i][j], 1);
while (!p.empty() && p.top().ff > now.ff)
{
pii q = p.top(); sum -= q.ff * q.ss;
now.ss += q.ss; p.pop();
}
sum += now.ff * now.ss;
p.push(now);
rs[i][j] = sum;
}
}
memset(c, 0, sizeof(c));
per(i, n, 1)
{
rep(j, 1, m)
{
if (a[i][j] || c[i][j]) continue;
while (c[i][j] < i && !a[i - c[i][j]][j]) c[i][j]++;
rep(k, 2, c[i][j]) c[i - k + 1][j] = c[i][j] - k + 1;
}
int sum = 0; stack<pii> p;
per(j, m, 1)
{
pii now = mp(c[i][j], 1);
while (!p.empty() && p.top().ff > now.ff)
{
pii q = p.top(); sum -= q.ff * q.ss;
now.ss += q.ss; p.pop();
}
sum += now.ff * now.ss;
p.push(now);
lx[i][j] = sum;
}
sum = 0; while (!p.empty()) p.pop();
rep(j, 1, m)
{
pii now = mp(c[i][j], 1);
while (!p.empty() && p.top().ff > now.ff)
{
pii q = p.top(); sum -= q.ff * q.ss;
now.ss += q.ss; p.pop();
}
sum += now.ff * now.ss;
p.push(now);
rx[i][j] = sum;
}
}
}
int main()
{
while (scanf("%d%d", &n, &m) != EOF)
{
rep(i, 0, n + 1) rep(j, 0, m + 1) ls[i][j] = rs[i][j] = 0;
rep(i, 1, n)
{
scanf("%s", s + 1);
rep(j, 1, m) a[i][j] = s[j] - '0';
}
GetFour();
LL L = 0, R = 0, ans = 0;
rep(i, 1, n)
{
rep(j, 1, m) (R += ls[i][j]) %= mod;
(ans += L * R) %= mod; R = 0;
rep(j, 1, m) (L += rx[i][j]) %= mod;
}
L = R = 0;
rep(j, 1, m)
{
rep(i, 1, n) (R += ls[i][j]) %= mod;
(ans += L * R) %= mod; R = 0;
rep(i, 1, n) (L += rx[i][j]) %= mod;
}
rep(i, 1, n)
{
rep(j, 1, m)
{
rx[i][j] += rx[i - 1][j] + rx[i][j - 1] - rx[i - 1][j - 1];
(ans -= rx[i][j] * ls[i + 1][j + 1]) %= mod;
}
per(j, m, 1)
{
lx[i][j] += lx[i - 1][j] + lx[i][j + 1] - lx[i - 1][j + 1];
(ans -= lx[i][j] * rs[i + 1][j - 1]) %= mod;
}
}
printf("%lld\n", (ans + mod) % mod);
}
return 0;
}1815: Enterprising Escape
#include <iostream>
#include <cstring>
#include <stack>
#include <cstdio>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
const double eps=1e-8;
const double PI=acos(-1.0);
using namespace std;
struct st{
int x;
int y;
int step;
friend bool operator <(st a,st b){
return a.step>b.step;}
}node;
char a[1005][1005];
int v[1005][1005];
int d[][2]={{1,0},{0,1},{0,-1},{-1,0}};
int k,n,m,num;
map<char,int> s;
int bfs(int x,int y)
{
priority_queue<st>q;
node.x=x;
node.y=y;
node.step=0;
q.push(node);
v[x][y]=1;
while(!q.empty())
{
st tem=q.top();
//cout<<tem.x<<" "<<tem.y<<endl;
q.pop();
st tp;
if(tem.x>=m-1||tem.y>=n-1||tem.x<=0||tem.y<=0)
{
return tem.step;//cout<<"t:"<<e<<endl;
}
for(int i=0; i<4; i++)
{
tp.x=tem.x+d[i][0];
tp.y=tem.y+d[i][1];
if(v[tp.x][tp.y]) continue;
tp.step=tem.step+s[a[tp.x][tp.y]];
q.push(tp);
v[tp.x][tp.y]=1;
//cout<<tp<<endl;
}
}
return -1;
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
memset(v,0,sizeof(v));
char c;
scanf("%d%d%d",&k,&n,&m);
getchar();
for(int i=0;i<k;i++){
scanf("%c %d",&c,&num);
getchar();
s[c]=num;
}
int x,y;
for(int i=0;i<m;i++)
scanf("%s",a[i]);
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
if(a[i][j]=='E'){
x=i;y=j;
}
printf("%d\n",bfs(x,y));
}
return 0;
}1817: Bones’s Battery
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<math.h>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
const double pi=acos(-1.0);
const int inf = 0x3f3f3f3f;
const int maxn=100005;
const double eps=1e-8;
const long long INF=10000000000;
int n,k,m;
long long dis[105][105], red[105][105];
void init(long long dis[][105]){//初始化数组
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
if (i==j)dis[i][j]=0;
else dis[i][j]=INF;
}
}
}
void floyd(long long dis[][105]){//folyd 求各源点间的最短距离
for(int t=0;t<n;t++){
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
dis[i][j]=min(dis[i][j],dis[i][t]+dis[t][j]);
}
}
}
}
int main()
{
int t;
scanf ("%d",&t);
while (t--){
scanf ("%d%d%d",&n,&k,&m);
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
if (i==j)dis[i][j]=0;
else dis[i][j]=INF;
}
}
int u,v,val;
for (int i=0;i<m;i++){
scanf ("%d%d%d",&u,&v,&val);
dis[u][v]=dis[v][u]=val;
}
floyd(dis);
long long lo=1,hi=INF;
long long mid;
long long ans=INF;
while (lo<=hi){//二分答案
mid=(lo+hi)/2;
init(red);
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
red[i][j]= dis[i][j]<=mid?1:INF;//如果小于mid说明i->j只需要充一次电
}
}
floyd(red);//跑floyd
long long d=0;
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
if (red[i][j]>d)d=red[i][j];//求出充电次数最多的一条路径
}
}
if (d<=k){//如果次数小于k说明此时的距离符合
ans=mid;//保存
hi=mid-1;
}
else lo=mid+1;
}
printf ("%lld\n",ans);//输出
}
return 0;
} 1818: Crusher’s Code
#include<iostream>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;
int n;
int A[10];
void init(){
int B[10], v[105], sz = 0;
memcpy(B, A, sizeof(A));
memset(v, -1, sizeof(v));
sort(B, B + n);
for (int i = 0; i<n; i++)
if (v[B[i]] == -1) v[B[i]] = sz++;
for (int i = 0; i<n; i++) {
A[i] = v[A[i]];
}
}
int get_sta(int A[]){
int ret = 0;
for (int i = 0; i<n; i++) ret = ret * 8 + A[i];
return ret;
}
void get_arr(int S, int A[]){
for (int i = n - 1; i >= 0; i--){
A[i] = S % 8;
S /= 8;
}
}
const int MX = 1e5 + 5;
map<int, int>vis;
int sz, S[MX];
void bfs(int s){
vis.clear();
queue<int>q;
q.push(s);
vis[s] = 1;
while (!q.empty()){
int u = q.front(); q.pop();
get_arr(u, A);
for (int i = 0; i<n; i++)
for (int j = i + 1; j<n; j++)
if (A[i]>A[j]){
swap(A[i], A[j]);
int SS = get_sta(A);
if (vis[SS] == 0){
q.push(SS);
vis[SS] = 1;
}
swap(A[i], A[j]);
}
}
sz = 0;
for (map<int, int>::iterator it = vis.begin(); it != vis.end(); it++) {
S[sz] = it->first;
it->second = sz++;
}
}
double dp[MX];
//递推写法
double DP1(){
memset(dp, 0, sizeof(dp));
for (int k = 0; k<sz; k++){
int success = 0;
int sta = S[k];
get_arr(sta, A);
for (int i = 0; i<n; i++)
for (int j = 0; j<n; j++){
int l = min(i, j), r = max(i, j);
if (A[l]>A[r]){
swap(A[l], A[r]);
int SS = get_sta(A);
success++;
dp[k] += dp[vis[SS]] / (n*n);
swap(A[l], A[r]);
}
}
if (success>0) dp[k] = (dp[k] + 1)*n*n / success;
}
return dp[sz - 1];
}
double DP2(){
memset(dp, 0, sizeof(dp));
for (int k = 0; k<sz; k++){
int success = 0;
int sta = S[k];
get_arr(sta, A);
for (int l = 0; l<n - 1; l++){
int r = l + 1;
if (A[l]>A[r]){
swap(A[l], A[r]);
int SS = get_sta(A);
success++;
dp[k] += dp[vis[SS]] / (n - 1);
swap(A[l], A[r]);
}
}
if (success>0) dp[k] = (dp[k] + 1)*(n - 1) / success;
}
return dp[sz - 1];
}
//记忆化搜索写法
double DP1(int u){
if (u == 0) return dp[u] = 0;
if (dp[u] >= 0) return dp[u];
int sta = S[u];
get_arr(sta, A);
int success = 0;
dp[u] = 0;
for (int i = 0; i<n; i++){
for (int j = 0; j<n; j++){
int l = min(i, j), r = max(i, j);
if (A[l]>A[r]){
swap(A[l], A[r]);
int SS = get_sta(A);
success++;
dp[u] += DP1(vis[SS]) / (n*n);
swap(A[l], A[r]);
}
}
}
if (success>0) dp[u] = (dp[u] + 1)*n*n / success;
return dp[u];
}
double DP2(int u){
if (u == 0) return dp[u] = 0;
if (dp[u] >= 0) return dp[u];
int sta = S[u];
get_arr(sta, A);
int success = 0;
dp[u] = 0;
for (int i = 0; i<n - 1; i++){
int l = i, r = i + 1;
if (A[l]>A[r]){
swap(A[l], A[r]);
int SS = get_sta(A);
success++;
dp[u] += DP2(vis[SS]) / (n - 1);
swap(A[l], A[r]);
}
}
if (success>0) dp[u] = (dp[u] + 1)*(n - 1) / success;
return dp[u];
}
int main(){
int T;
scanf("%d", &T);
while (T--){
scanf("%d", &n);
for (int i = 0; i<n; i++) scanf("%d", &A[i]);
init();
int init_sta = get_sta(A);
bfs(init_sta);
for (int i = 0; i<sz; i++) dp[i] = 0;
double ans1 = DP1();
for (int i = 0; i<sz; i++) dp[i] = 0;
double ans2 = DP2();
printf("Monty %.6f Carlos %.6f\n", ans1, ans2);
}
return 0;
}1826: Languages
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<math.h>
#include<map>
#include<queue>
#include<sstream>
#include<algorithm>
using namespace std;
const double pi=acos(-1.0);
const int inf = 0x3f3f3f3f;
const int maxn=100005;
const double eps=1e-8;
int n;
map<string,string>mp;//map
string a,b,c;
int main()
{
scanf ("%d",&n);
mp.clear();//清空
getchar(); //得将换行符吃掉，没加这个就过不了
for (int i=0;i<n;i++){
getline(cin,a);
stringstream ss(a);//定义
ss>>b;//先输入语言名称
while (ss>>c){
for (int j=0;j<c.size();j++){
if (c[j]>='A'&&c[j]<='Z'){
c[j]+=32;//改成小写
}
}
mp[c]=b;//映射
}
}
while (getline(cin,a)){
string tmp;
int len=a.size();
for (int i=0;i<len;i++){//把标点符号改成空格
if (a[i]==','||a[i]=='.'||a[i]=='!'||a[i]==';'||a[i]=='?'||a[i]=='('||a[i]==')'){
a[i]=' ';
}
}
stringstream ss1(a);//定义
while (ss1>>tmp){
for (int i=0;i<tmp.size();i++){
if (tmp[i]>='A'&&tmp[i]<='Z'){
tmp[i]+=32;//该小写
}
}
if (mp.count(tmp)){
cout<<mp[tmp]<<endl;//如果找到就输出
break;
}
}
}
return 0;
}1828: Dictionary
#include<iostream>
#include<cstdio>
using namespace std;
#define ll long long
int f[10];
void init()
{
f[1]=1;
for(int i=2;i<10;i++)
f[i]=f[i-1]*i;
}
int main()
{
int N,M;
char s[10];
init();
scanf("%d",&N);
while(N--)
{
int ans=0;
scanf("%s",s);
for(int i=0;i<9;i++)
{
int temp=0;
for(int j=i+1;j<9;j++)
if(s[j]<s[i])temp++;
ans+=temp*f[9-i-1];
}
printf("%d\n",ans+1);
}
return 0;
}1830: FarAway
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int maxn=1e5+10;
int dis[maxn];
struct Edge{
int v,val;
};
vector<Edge>G[maxn];
void bfs(){
queue<int>q;
q.push(1);
dis[1]=0;
while (!q.empty()){
int u=q.front();q.pop();
for (int i=0;i<G[u].size();i++){
int v=G[u][i].v;
dis[v]=dis[u]+G[u][i].val;
q.push(v);
}
}
}
int C,M;
int main()
{
int T;
scanf ("%d",&T);
while (T--){
scanf ("%d%d",&C,&M);
for (int i=0;i<=C;i++)G[i].clear();
int u,v,val;
for (int i=0;i<C-1;i++){
scanf ("%d%d%d",&u,&v,&val);
G[u].push_back(Edge{v,val});
}
bfs();
int ans=0;
for (int i=1;i<=C;i++){
ans=max(dis[i],ans);
}
if (ans>=M)printf ("%d\n",ans);
else printf ("-1\n");
}
return 0;
}1831: Found
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
const int mod = 9973;
int n,m;
long long num;
int mp[105][105];
struct matrix{
int mat[105][105];
matrix operator * (const matrix& t) const{
matrix tmp;
for (int i=0;i<n*n;i++){
for (int j=0;j<n*n;j++){
tmp.mat[i][j]=0;
for (int k=0;k<n*n;k++){
tmp.mat[i][j]+=mat[i][k]*t.mat[k][j]%mod;
tmp.mat[i][j]%=mod;
}
}
}
return tmp;
}
}res;
matrix Pow(matrix &t,long long num){
matrix ans;
memset (ans.mat,0,sizeof (ans.mat));
for (int i=0;i<n;i++) ans.mat[i][i]=1;
while(num){
if (num&1) ans=ans*t;
num>>=1;
t=t*t;
}
return ans;
}
int main()
{
int cas;
scanf ("%d",&cas);
while (cas--){
scanf ("%d%d%lld",&n,&m,&num);
memset (mp,0,sizeof (mp));
memset (res.mat,0,sizeof (res.mat));
int u,v;
for (int i=0;i<m;i++){
scanf ("%d%d",&u,&v);
mp[u][v]=1;
mp[v][u]=1;
}
for (int i=0;i<n*n;i++){
int x1=i%n+1,y1=i/n+1;//x1表示a当前的位置，y1表示b当前的位置
if (x1==y1) continue;//a,b两个人的位置不能一样
for (int j=0;j<n*n;j++){
int x2=j%n+1,y2=j/n+1;//x2表示a下一分钟可能到达的位置，y1表示b下一分钟可能到达的位置
if(x2==y2)continue;
if (x1==x2||y1==y2)continue;//a,b移动前后不能一样
if (!mp[x1][x2]||!mp[y1][y2]) continue;
res.mat[i][j]=1;
}
}
res=Pow(res,num-1);
int ans=0;
for (int i=0;i<n*n;i++){
int x1=i%n+1,y1=i/n+1;
if (x1==y1)continue;
//n-1表示的是初始状态（0，n-1 ==> 也就是一开始a在0，b在n-1的位置)
//然后最终在i这个位置相遇，而i这个状态中，a的位置为i%n+1,b的位置为i/n+1
if (!res.mat[n-1][i])continue;
for (int j=1;j<=n;j++){
if (mp[x1][j]&&mp[y1][j]){//如果两个人在下一秒能同时移动到同一点
ans+=res.mat[n-1][i]%mod;
ans%=mod;
}
}
}
printf ("%d\n",ans);
}
return 0;
} 1835: Pry Sequence Transformation
#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
const int MX = 2e4 + 5;
char S[MX],T[MX];
double dp[2][MX];
int val(char c){return c-'a'+1;}
double INS(char c){return 1+val(c)*0.01;}
double REP(char c1,char c2){return c1==c2?0:(val(c1)+val(c2))*0.1;}
int main(){
int cas;
int k;
//freopen("in.txt","r",stdin);
scanf("%d",&cas);
while(cas--){
scanf("%d",&k);
scanf("%s%s",S+1,T+1);
int n=strlen(S+1),m=strlen(T+1);
dp[0][0]=0;
for(int i=1;i<=k;i++) dp[0][i]=dp[0][i-1]+INS(T[i]);
int cur,pre;
for(int i=1;i<=n;i++){
cur=i%2;
pre=cur^1;
dp[cur][0]=i;
int mx=min(m,i+k+1);
for(int j=max(1,i-k-1);j<=mx;j++){
dp[cur][j]=dp[pre][j-1]+REP(S[i],T[j]);
if(abs(i-j)<=k) dp[cur][j]=min(dp[cur][j],dp[pre][j]+1);
if(abs(j-i)<=k) dp[cur][j]=min(dp[cur][j],dp[cur][j-1]+INS(T[j]));
}
}
if(dp[cur][m]>k) printf("TOSS\n");
else printf("%.4f\n",dp[cur][m]);
}
return 0;
}1837: Tree Count
#include<cstdio>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
#include<string>
#include<iostream>
#include<sstream>
using namespace std;
typedef unsigned long long ULL;
const int MX = 7e4 + 5;
const int inf = 0x3f3f3f3f;
const int P1 = 1000001;
const int P2 = 3111111;
queue<int>q;
struct Edge{
int u,v,nxt;
}E[MX*4];
ULL H[MX];
int val[MX],level[MX],head[MX],tot,IN[MX];
char buff[MX*100];
void init(){
while(!q.empty())q.pop();
memset(IN,0,sizeof(IN));
memset(head,-1,sizeof(head));
memset(level,0,sizeof(level));
tot=0;
}
void add(int u,int v){
E[tot].u=u;
E[tot].v=v;
E[tot].nxt=head[u];
head[u]=tot++;
IN[v]++;
}
struct Tree{
int n,root[2],rt;
ULL Hash[2];
void top_sort(){
for(int i=1;i<=n;i++) if(IN[i]==1) q.push(i);
int Max_L=0;
while(!q.empty()){
int u=q.front();q.pop();
Max_L=max(Max_L,level[u]);
for(int i=head[u];~i;i=E[i].nxt){
int v=E[i].v;
IN[v]--;
if(IN[v]==1){
level[v]=level[u]+1;
q.push(v);
}
}
}
rt=0;
for(int i=1;i<=n;i++) if(level[i]==Max_L) {
root[rt++]=i;
}
}
void read(){
n=1;
gets(buff);
int u=0,v=0,len=strlen(buff);
buff[len++]=' ';
for(int i=0,j=0;i<len;i++){
if(buff[i]==' ') {
if(j%2==1) {
add(u,v);add(v,u);
u=v=0;
n++;
}
j++;
continue;
}
if(j%2==0) u=u*10+buff[i]-'0';
else v=v*10+buff[i]-'0';
}
for(int i=1;i<=n;i++) scanf("%d",&val[i]);
gets(buff);
}
}T[105];
int dfs(int u,int fa){
if(fa==-1) H[u]=P1;
else H[u]=(ULL)(val[fa]-val[u])^P1;
for(int i=head[u];~i;i=E[i].nxt){
int v=E[i].v;
if(v==fa) continue;
H[u]*=dfs(v,u)^P2;
}
return H[u];
}
bool cmp(int x,int y){
for(int i=0;i<T[x].rt;i++){
for(int j=0;j<T[y].rt;j++){
if(T[x].Hash[i]==T[y].Hash[j]) return 1;
}
}
return 0;
}
int vis[105];
vector<int>v[105];
int main(){
int d;
//freopen("in.txt","r",stdin);
while(~scanf("%d\n",&d)){
for(int i=0;i<d;i++) {
init();
T[i].read();
T[i].top_sort();
for(int j=0;j<T[i].rt;j++) T[i].Hash[j]=dfs(T[i].root[j],-1);
}
for(int i=0;i<d;i++) v[i].clear();
memset(vis,0,sizeof(vis));
for(int i=0;i<d;i++){
if(vis[i]) continue;
for(int j=i+1;j<d;j++){
if(vis[j]||T[i].n!=T[j].n) continue;
if(cmp(i,j)){
vis[i]=vis[j]=1;
v[i].push_back(j);
}
}
}
int tot=d;
priority_queue<int,vector<int>,greater<int> >Q;
for(int i=0;i<d;i++) if(v[i].size()>0){
tot-=v[i].size()+1;
Q.push(v[i].size()+1);
}
for(int i=0;i<tot;i++) Q.push(1);
printf("%d",Q.top());Q.pop();
while(!Q.empty()){
printf(" %d",Q.top());Q.pop();
}
printf("\n");
}
return 0;
}1838: Water Pump
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<stack>
#define MAXN 100000
#define INF 2147483647
using namespace std;
struct node
{
int h,id;
node(){}
node(int _h,int _id):h(_h),id(_id){}
};
int lh[MAXN],rh[MAXN],wah[MAXN],l[MAXN],r[MAXN];
int sl[MAXN],sr[MAXN],a[MAXN],n;
stack<node> q;
int main()
{
int t;
scanf("%d",&t);
while (t--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
lh[i]=rh[i]=wah[i]=l[i]=r[i]=sl[i]=sr[i]=0;
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
// calculate the first higher pump from the left and right
q.push(node(INF,0));
for(int i=1;i<=n;i++)
{
while (a[i]>q.top().h) q.pop();
lh[i]=q.top().id;
q.push(node(a[i],i));
}
while (!q.empty()) q.pop();
q.push(node(INF,0));
for(int i=n;i>=1;i--)
{
while (a[i]>q.top().h) q.pop();
rh[i]=q.top().id;
q.push(node(a[i],i));
}
// calculate the height of the water of each segment
int i=1,j=1;
while (rh[i])
{
while (j<rh[i])
{
l[j]=i,r[j]=rh[i];
wah[j++]=a[i];
}
i=rh[i];
}
i=j=n;
while(lh[i])
{
while (j>lh[i])
{
wah[--j]=a[i];
l[j]=lh[i],r[j]=i;
}
i=lh[i];
}
//calculate possible sum of the water above left and right
for(int i=2;i<=n;i++)
if (lh[i]) sl[i]=sl[lh[i]]+(i-lh[i])*a[i];
else sl[i]=wah[i-1]*(r[i-1]-l[i-1])+sl[l[i-1]];
for(int i=n-1;i>0;i--)
if (rh[i]) sr[i]=sr[rh[i]]+(rh[i]-i)*a[i];
else sr[i]=wah[i]*(r[i]-l[i])+sr[r[i]];
//find maximum answer
int ans=0;
for(int i=1;i<n;i++)
{
int lwa=sl[i]-sl[l[i]];
int rwa=sr[i+1]-sr[r[i]];
int water=wah[i]*(r[i]-l[i]);
ans=max(ans,water-lwa-rwa);
}
printf("%d\n",ans);
}
}1839: Who Feels Lucky
#include<cstdio>
#include<algorithm>
#include<string.h>
#include<iostream>
#define fuck(x) cout<<"["<<x<<"]"<<endl
using namespace std;
const int MX = 35;
const double eps=1e-6;
int a[MX],b[MX],tot[MX],s1[MX],s2[MX];
double L,R;
double get_L(int i,int k){return 1.0*(k*tot[i]-b[i])/s1[i];}
double get_R(int i,int k){return 1.0*k*tot[i]/s2[i];}
int get_K(int i,double t,bool &flag){
int cnt=(int)t/tot[i];
if (cnt*tot[i]==t) cnt--;
flag=cnt*tot[i]+a[i]>t?0:1;
return ++cnt;
}
bool check(int i){
bool flag1,flag2;
double l,r;
int maxK=get_K(i,R*s2[i],flag1);
int minK=get_K(i,L*s1[i],flag2);
if (maxK<minK||maxK==minK&&!flag1&&!flag2) return 0;
for (int k=maxK;k>=minK;k--){
r=get_R(i,k);
l=get_L(i,k);
if(r<L||l>R) continue;
R=min(R,r);
L=max(L,l);
return 1;
}
return 0;
}
int main(){
//freopen("in.txt","r",stdin);
int n,T;
scanf("%d",&T);
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;i++) {
scanf("%d%d%d%d",&a[i],&b[i],&s1[i],&s2[i]);
tot[i]=a[i]+b[i];
}
int flag=0,i;
int K=b[n]*s2[n]/((s2[n]-s1[n])*tot[n]);
for(int k=K;k>0;k--){
L=get_L(n,k);R=get_R(n,k);
for(i=1;i<=n;i++) if(!check(i)) break;
if(i==n+1){
flag=1;
break;
}
}
if(!flag) printf("IMPOSSIBLE\n");
else printf("%.4lf\n",1.0/R);
}
return 0;
}1840: Lawn mower
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string.h>
using namespace std;
double xi[1005],yi[1005];
int main()
{
int nx,ny;
double w;
while(cin>>nx>>ny>>w)
{
bool suc=true;
if(nx==0&&ny==0&&abs(w)<1e-5)
break;
for(int i=0;i<nx;i++)
cin>>xi[i];
for(int i=0;i<ny;i++)
cin>>yi[i];
sort(xi,xi+nx);
sort(yi,yi+ny);
double endx=xi[0]+w/2.0;
double endy=yi[0]+w/2.0;
for(int i=1;i<nx;i++)
if(endx<xi[i]-w/2.0)
{
suc=false;
break;
}
else
endx=xi[i]+w/2.0;
if(endx<75&&suc)
suc=false;
if(suc)
{
for(int i=1;i<ny;i++)
if(endy<yi[i]-w/2.0)
{
suc=false;
break;
}
else
endy=yi[i]+w/2.0;
if(endy<100)
suc=false;
}
if(suc)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}1842: Fake scoreboard
#include<iostream>
#define MAX_V 200
#include<string.h>
using namespace std;
int n,m;
namespace MaxNetFlow
{
struct Edge
{
int dest,cap;
Edge *next,*pair;
Edge() {}
Edge(int _dest,int _cap,Edge* _next):dest(_dest),cap(_cap),next(_next){}
};
Edge *e[MAX_V],*c[MAX_V],*p[MAX_V];
int Stack[MAX_V],Queue[MAX_V],dist[MAX_V];
int s,t,maxflow,top;
inline void clear()
{
memset(e,0,sizeof(e));
}
inline void addedge(int a,int b,int c)
{
e[a]=new Edge(b,c,e[a]);
e[b]=new Edge(a,0,e[b]);
e[a]->pair=e[b],e[b]->pair=e[a];
}
inline bool lab()
{
memset(dist,0x3f,sizeof(dist));
dist[s]=0; Queue[1]=s;
for (int l=1,r=1;l<=r;l++)
{
int i=Queue[l];
for (Edge *j=e[i];j;j=j->next)
if (j->cap && dist[j->dest]>dist[i]+1)
{
dist[j->dest]=dist[i]+1;
if (j->dest==t) return 1;
Queue[++r]=j->dest;
}
}
return 0;
}
inline void aug()
{
int top=0; Stack[++top]=s;
memcpy(c,e,sizeof(e));
while (top)
{
int i=Stack[top];
if (i!=t)
{
Edge *j;
for (j=c[i];j;j=j->next)
if (j->cap && dist[j->dest]==dist[i]+1) break;
if (j) top++,Stack[top]=j->dest,c[i]=p[top]=j;
else top--,dist[i]=1e9;
} else
{
int delta=1e9;
for (int i=top;i>=2;i--)
delta=std::min(delta,p[i]->cap);
maxflow+=delta;
for (int i=top;i>=2;i--)
{
p[i]->cap-=delta,p[i]->pair->cap+=delta;
if (!p[i]->cap) top=i-1;
}
}
}
}
inline int dinic()
{
maxflow=0;
while (lab()) aug();
return maxflow;
}
inline void BuildAnswer()
{
for(int i=1;i<=n;i++)
{
for(Edge *j=e[i];j;j=j->next)
{
if (j->dest==s || j->dest==t) continue; //连向源汇的边当然不用产生答案
bool flag=(j->cap);
if (!flag)
{
addedge(s,i,1);
addedge(j->dest,t,1);
j->cap=j->pair->cap=0; //尝试封死这条边
dinic(); //看是否能找到增广路
if (maxflow<=0) e[s]->cap=e[j->dest]->cap=0; //找不到则封死新加的边
else flag=1;
}
j->cap=j->pair->cap=0; //直接封死该边
if (flag) putchar('N');
else putchar('Y');
}
putchar('\n');
}
}
}
int main()
{
while (~scanf("%d%d",&n,&m) && n && m)
{
int sum1=0,sum2=0,c;
MaxNetFlow::clear();
int s=MaxNetFlow::s=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&c); sum1+=c;
MaxNetFlow::addedge(s,i,c);
}
int t=MaxNetFlow::t=n+m+1;
for(int i=1;i<=m;i++)
{
scanf("%d",&c); sum2+=c;
MaxNetFlow::addedge(i+n,t,c);
}
for(int i=n;i>=1;i--)
for(int j=m;j>=1;j--) //因为BuildAnswer()遍历边的时候是按照先加入后遍历的
MaxNetFlow::addedge(i,j+n,1); //所以为了满足字典序，我们就从后往前加边
MaxNetFlow::dinic();
int maxflow=MaxNetFlow::maxflow;
if (sum1!=sum2 || maxflow!=sum1) {puts("Impossible\n");continue;}
MaxNetFlow::BuildAnswer();
putchar('\n');
}
}1843: Jumping monkey
#include<iostream>
#include<string.h>
#include<map>
#include<queue>
using namespace std;
deque<int> que,ans;
int num[1<<21],fa[1<<21];
int n,m,nxt[21];
bool v[1<<21];
int main()
{
while(~scanf("%d%d",&n,&m) && n)
{
bool flag=0; int l=1<<n;
for(int i=0;i<l;i++) v[i]=fa[i]=0;
memset(nxt,0,sizeof(nxt));
for(int i=1;i<=m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
nxt[u]|=(1<<v);
nxt[v]|=(1<<u);
}
if (m>n-1)
{
puts("Impossible");
continue;
}
v[(1<<n)-1]=1;
que.clear();
que.push_back((1<<n)-1);
while (!que.empty() && !flag)
{
int cur=que.front();
que.pop_front();
for(int i=0;i<n;i++)
{
int next=0;
if (cur&(1<<i))
{
for(int j=0;j<n;j++)
if ((cur&(1<<j)) && j!=i) next|=nxt[j];
if (!v[next])
{
v[next]=1;
num[next]=i;
fa[next]=cur;
que.push_back(next);
if (!next) {flag=1;break;}
}
}
}
}
if (flag)
{
ans.clear();
for(int cur=0;fa[cur];cur=fa[cur])
ans.push_back(num[cur]);
printf("%d: ",ans.size());
for(int i=ans.size()-1;i>=0;i--)
printf("%d%c",ans[i],!i? '\n':' ');
} else puts("Impossible");
}
return 0;
}1846: Assembly line
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int cost[128][128],sz,dp[210][210][26],n,m,len;
char sym[26],ch[128][128],str[210];
bool first;
int main(){
ios_base::sync_with_stdio(false);
while(cin>>n&&n){
if(first)
cout<<endl;
else
first=true;
for(int i=0;i<n;++i)
cin>>sym[i];
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
cin>>cost[sym[i]][sym[j]]>>ch[sym[i]][sym[j]]>>ch[sym[i]][sym[j]];
cin>>m;
while(m--){
memset(dp,-1,sizeof dp);
cin>>str;
len=strlen(str);
for(int i=0;i<len;++i)
dp[i][i][str[i]]=0;
for(int length=2;length<=len;++length)
for(int i=0,j=length-1;j<len;++i,++j)
for(int k=i;k<j;++k)
for(int le=0;le<n;++le)
if(dp[i][k][sym[le]]!=-1)
for(int ri=0;ri<n;++ri)
if(dp[k+1][j][sym[ri]]!=-1)
if(dp[i][j][ch[sym[le]][sym[ri]]]==-1||dp[i][j][ch[sym[le]][sym[ri]]]>dp[i][k][sym[le]]+dp[k+1][j][sym[ri]]+cost[sym[le]][sym[ri]])
dp[i][j][ch[sym[le]][sym[ri]]]=dp[i][k][sym[le]]+dp[k+1][j][sym[ri]]+cost[sym[le]][sym[ri]];
int ans=-1;
for(int i=0;i<n;++i)
if(dp[0][len-1][sym[i]]!=-1)
ans=(ans==-1?i:(dp[0][len-1][sym[i]]<dp[0][len-1][sym[ans]]?i:ans));
cout<<dp[0][len-1][sym[ans]]<<'-'<<sym[ans]<<endl;
}
}
return 0;
}1848: 3-sided dice
#include<cstdio>
#include<algorithm>
#include<string.h>
#include<stdlib.h>
using namespace std;
struct node{
int x,y,z;
node(){}
node(int X,int Y,int Z){x=X;y=Y;z=Z;}
bool operator==(const node P)const{
return x==P.x&&y==P.y&&z==P.z;
}
}p[5];
int Cross(int i,int j,int k){
node v1(p[i].x-p[k].x,p[i].y-p[k].y,p[i].z-p[k].z),v2(p[j].x-p[k].x,p[j].y-p[k].y,p[j].z-p[k].z);
return (v1.y*v2.z-v1.z*v2.y)+(v1.z*v2.x-v1.x*v2.z)+(v1.x*v2.y-v1.y*v2.x);
}
bool check(int i,int j,int k){
node v1(p[k].x-p[i].x,p[k].y-p[i].y,p[k].z-p[i].z),v2(p[k].x-p[j].x,p[k].y-p[j].y,p[k].z-p[j].z);
//向量每项必须符号相反(有一个为0，另一个也必须是0)，否则两向量不相反
if((v1.x==0&&v2.x!=0)||(v1.x!=0&&v2.x==0)) return 0;
if((v1.y==0&&v2.y!=0)||(v1.y!=0&&v2.y==0)) return 0;
if((v1.z==0&&v2.z!=0)||(v1.z!=0&&v2.z==0)) return 0;
if(v1.x*v2.x>0||v1.y*v2.y>0||v1.z*v2.z>0) return 0;
//如果A=α*B(α<0),那么A与B共线且方向相反
if(v1.x==0&&v1.y==0&&v1.z==0) return 0;
if(v1.x!=0&&v1.y!=0&&v1.x*v2.y!=v1.y*v2.x) return 0;
if(v1.x!=0&&v1.z!=0&&v1.x*v2.z!=v1.z*v2.x) return 0;
if(v1.y!=0&&v1.z!=0&&v1.y*v2.z!=v1.z*v2.y) return 0;
return 1;
}
int main(){
//freopen("in.txt","r",stdin);
while(~scanf("%d%d%d",&p[0].x,&p[0].y,&p[0].z),p[0].x||p[0].y||p[0].z){
for(int i=1;i<4;i++) scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
if(p[0]==p[1]&&p[1]==p[2]) { //3个向量相等
printf("%s\n",p[3]==p[0]?"YES":"NO");
continue;
}
int area=abs(Cross(0,1,2));
if(area==0){ //3条向量共面
if(p[0]==p[1]||p[0]==p[2]||p[1]==p[2]) {
bool flag;
if(p[0]==p[1]) flag=check(0,2,3);
else if(p[0]==p[2]) flag=check(0,1,3);
else flag=check(1,2,3);
printf("%s\n",flag?"YES":"NO");
}
else printf("%s\n",(check(0,1,3)||check(0,2,3)||check(1,2,3))?"YES":"NO");
}
else{
//第四个点必须在三角形内
//每个向量的可能性必须大于0，3个小三角形面积必须大于0且等于总面积
int area1=abs(Cross(0,1,3));
int area2=abs(Cross(0,2,3));
int area3=abs(Cross(1,2,3));
if(area1>0&&area2>0&&area3>0&&area==area1+area2+area3) printf("YES\n");
else printf("NO\n");
}
}
return 0;
}1849: Comparing answers
#include <cstdio>
#include <iostream>
#include <set>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
using ll = long long;
const int maxn = 1e3 + 9;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll n, M = 1e9;
vec mul(mat &A, vec &B)
{
vec C(A.size());
for (int i = 0; i<A.size(); i++)
for (int j = 0; j<B.size(); j++){
C[i] = (C[i] + A[i][j] * B[j]);
}
return C;
}
int main()
{
while (cin >> n){
if (n == 0)break;
mat A(n, vec(n)), B(n, vec(n));
for (int i = 0; i<n; i++)
for (int j = 0; j<n; j++)
cin >> A[i][j];
for (int i = 0; i<n; i++)
for (int j = 0; j<n; j++)
cin >> B[i][j];
vec H(n), TE(n);
for (int i = 0; i<n; i++){
H[i] = i + 1;
TE[i] = i + 1;
}
H = mul(A, H);
H = mul(A, H);
TE = mul(B, TE);
int f = 1;
for (int i = 0; i<n; i++){
if (TE[i] != H[i])
f = 0;
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}1850: Grade School Multiplication
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
void PrintLine(int len)
{
while (len--)
printf("-");
printf("\n");
}
int main(void)
{
long long x,y;
int num = 1;
while (scanf("%lld %lld", &x, &y))
{
if (x==0&&y==0)
break;
printf("Problem %d\n",num++);
long long s, ss, yy;
int f=0;
s = x*y;
ss=s;
yy=y;
int len = 0;
while (ss)
{
len++;
ss/=10;
}
int lenx = (int)log10(x)+1;
int leny = (int)log10(y)+1;
for (int i = 0; i < len-lenx; i++)
printf(" ");
printf("%lld\n",x);
for (int i = 0; i < len-leny; i++)
printf(" ");
printf("%lld\n",y);
PrintLine(len);
int p = 0, t=0;
s = 1;
while (yy)
{
while (yy%10==0)
{
yy/=10;
p++;
t++;
}
s = s * (yy%10) * x;
yy/=10;
int lens = (int)log10(s)+1;
for (int i = 0; i < len-lens-p; i++)
printf(" ");
printf("%lld",s);
for (int i = 0; i < t; i++)
printf("0");
printf("\n");
s = 1;
f++;
t=0;
p++;
}
if (f>1)
{
PrintLine(len);
s = x*y;
printf("%lld\n",s);
}
}
return 0;
}1853: Su-domino-ku
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define rep(i,j,k) for (int i = j; i <= k; i++)
const int maxn = 5e5 + 10;
int n, a, b, tot, X, Y, T = 0;
int r[10][10], c[10][10], d[10][10], f[10][10], mp[10][10];
int p[maxn][6];
char x[3], y[3], s[11][11];
struct DLX
{
int L[maxn], R[maxn], U[maxn], D[maxn];
int row[maxn], col[maxn], ans[maxn], cnt[maxn];
int n, m, num, sz;
void add(int now, int l, int r, int u, int d, int x, int y)
{
L[now] = l; R[now] = r; U[now] = u;
D[now] = d; row[now] = x; col[now] = y;
}
void reset(int n, int m)
{
this->n = n; this->m = m;
for (int i = 0; i <= m; i++)
{
add(i, i - 1, i + 1, i, i, 0, i);
cnt[i] = 0;
}
L[0] = m; num = R[m] = 0; sz = m + 1;
}
void insert(int x, int y)
{
int ft = sz - 1;
if (row[ft] != x)
{
add(sz, sz, sz, U[y], y, x, y);
U[D[sz]] = sz; D[U[sz]] = sz;
}
else
{
add(sz, ft, R[ft], U[y], y, x, y);
R[L[sz]] = sz; L[R[sz]] = sz;
U[D[sz]] = sz; D[U[sz]] = sz;
}
++cnt[y]; ++sz;
}
void remove(int now)
{
R[L[now]] = R[now];
L[R[now]] = L[now];
for (int i = D[now]; i != now; i = D[i])
for (int j = R[i]; j != i; j = R[j])
{
D[U[j]] = D[j];
U[D[j]] = U[j];
--cnt[col[j]];
}
}
void resume(int now)
{
for (int i = U[now]; i != now; i = U[i])
for (int j = L[i]; j != i; j = L[j])
{
D[U[j]] = j;
U[D[j]] = j;
++cnt[col[j]];
}
R[L[now]] = now;
L[R[now]] = now;
}
bool dfs(int x)
{
if (!R[0]) { num = x; return true; }
int now = R[0];
for (int i = now; i != 0; i = R[i])
if (cnt[now]>cnt[i]) now = i;
remove(now);
for (int i = D[now]; i != now; i = D[i])
{
ans[x] = row[i];
for (int j = R[i]; j != i; j = R[j]) remove(col[j]);
if (dfs(x + 1)) return true;
for (int j = L[i]; j != i; j = L[j]) resume(col[j]);
}
resume(now);
return false;
}
void display()
{
for (int i = 0; i < num; ++i)
{
if (ans[i] == 1) continue;
s[p[ans[i]][0]][p[ans[i]][1]] = p[ans[i]][2] + '0';
s[p[ans[i]][3]][p[ans[i]][4]] = p[ans[i]][5] + '0';
}
for (int i = 1; i <= 9; i++) s[i][10] = 0, puts(s[i] + 1);
}
}dlx;
int un(int x, int y) { return (x - 1) / 3 * 3 + (y - 1) / 3; }
void insert(int x, int y, int z)
{
dlx.insert(tot, 9 * (x - 1) + y);
dlx.insert(tot, 81 + 9 * (x - 1) + z);
dlx.insert(tot, 162 + 9 * (y - 1) + z);
dlx.insert(tot, 243 + 9 * un(x, y) + z);
}
int main()
{
while (scanf("%d", &n) != EOF, n)
{
tot = 1;
dlx.reset(2000, 405);
memset(r, 0, sizeof(r));
memset(f, 0, sizeof(f));
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
memset(mp, 0, sizeof(mp));
rep(i, 1, n)
{
scanf("%d%s%d%s", &a, x, &b, y);
f[min(a, b)][max(a, b)] = 1;
X = x[0] - 'A' + 1, Y = x[1] - '0';
r[X][a] = c[Y][a] = mp[X][Y] = d[un(X, Y)][a] = 1;
insert(X, Y, a); s[X][Y] = '0' + a;
X = y[0] - 'A' + 1, Y = y[1] - '0';
r[X][b] = c[Y][b] = mp[X][Y] = d[un(X, Y)][b] = 1;
insert(X, Y, b); s[X][Y] = '0' + b;
dlx.insert(tot, 324 + (a - 1) * 9 + b);
dlx.insert(tot, 324 + (b - 1) * 9 + a);
}
rep(i, 1, 9)
{
scanf("%s", x);
X = x[0] - 'A' + 1, Y = x[1] - '0';
r[X][i] = c[Y][i] = mp[X][Y] = d[un(X, Y)][i] = 1;
insert(X, Y, i); s[X][Y] = '0' + i;
dlx.insert(tot, 324 + (i - 1) * 9 + i);
}
rep(i, 1, 9)
{
rep(j, 1, 9)
{
if (mp[i][j]) continue;
rep(x, 1, 9)
{
if (r[i][x] || c[j][x] || d[un(i, j)][x]) continue;
rep(y, 1, 9)
{
if (x == y || f[min(x, y)][max(x, y)]) continue;
if (i + 1 < 10 && !mp[i + 1][j])
{
if (!(r[i + 1][y] || c[j][y] || d[un(i + 1, j)][y]))
{
++tot;
insert(i, j, x);
insert(i + 1, j, y);
dlx.insert(tot, 324 + 9 * (x - 1) + y);
dlx.insert(tot, 324 + 9 * (y - 1) + x);
p[tot][0] = i; p[tot][1] = j; p[tot][2] = x;
p[tot][3] = i + 1; p[tot][4] = j; p[tot][5] = y;
}
}
if (j + 1 < 10 && !mp[i][j + 1])
{
if (!(r[i][y] || c[j + 1][y] || d[un(i, j + 1)][y]))
{
++tot;
insert(i, j, x);
insert(i, j + 1, y);
dlx.insert(tot, 324 + 9 * (x - 1) + y);
dlx.insert(tot, 324 + 9 * (y - 1) + x);
p[tot][0] = i; p[tot][1] = j; p[tot][2] = x;
p[tot][3] = i; p[tot][4] = j + 1; p[tot][5] = y;
}
}
}
}
}
}
dlx.dfs(0);
printf("Puzzle %d\n", ++T);
dlx.display();
}
return 0;
}1857: Crash and Go(relians)
#include <cstdio>
#include <iostream>
#include <set>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
using ll=long long;
const int maxn= 1e2 +9;
int n;
struct po
{
double x,y,r;
}te;
vector<po> vp;
double dis(po u,po v)
{
return sqrt((u.x-v.x)*(u.x-v.x)+(u.y-v.y)*(u.y-v.y));
}
bool ok(po u,po v)
{
return dis(u,v)<max(u.r,v.r);
}
void sol(int pos,vector<po>& tt)
{
double x=0,y=0,r=0;
for(int i=0;i<tt.size();i++){
x+=tt[i].x;
y+=tt[i].y;
r+=tt[i].r*tt[i].r;
}
vp[pos].x=x/tt.size();
vp[pos].y=y/tt.size();
vp[pos].r=sqrt(r);
}
int main()
{
while(cin>>n){
if(n==0) break;
vp.clear();
for(int i=0;i<n;i++){
double u,v,r;
cin>>u>>v>>r;
vp.push_back(po{u,v,r});
}
for(int i=0;i<n;i++) {
vector<po> feasible;
feasible.push_back(vp[i]);
for(int j=0;j<i;j++) if(vp[j].r>0)
{
if(ok(vp[i],vp[j])){
feasible.push_back(vp[j]);
vp[j].r=-1;
}
}
if(feasible.size()>1){
sol(i,feasible);
//这块就是新合成的一个圆 所以你要把它再循环一遍看之前有没有可以联系上的其他人
i--;
}
}
int ans=0;
for(int i=0;i<n;i++){ if(vp[i].r>0) ans++;
}
cout<<ans<<endl;
}
return 0;
}1859: Gone Fishing
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=25+5;
int n,toalltime;
int fishBone[maxn],cost[maxn],finalTime[maxn];
struct node
{
int fishes;
int id;
int theMinus;
node(int fishes=0,int id=0,int theMinus=0):fishes(fishes),id(id),theMinus(theMinus){};
bool operator <(const node& p) const
{
return fishes>p.fishes||(fishes==p.fishes&&id<p.id);
}
}t[maxn];
int main()
{
while(~scanf("%d",&n))
{
if(!n)
return 0;
int ans=-1;
scanf("%d",&toalltime);
toalltime*=60;
memset(fishBone,0,sizeof(fishBone));
for(int i=0;i<n;i++)
{
int x;
scanf("%d",&x);
t[i].id=i;
t[i].fishes=x;
}
for(int i=0;i<n;i++)
{
int x;
scanf("%d",&x);
t[i].theMinus=x;
}
for(int i=0;i<n-1;i++)
{
scanf("%d",&cost[i]);
}
int tmptime[maxn];
int tmpsum=0;
for(int i=0;i<n;i++)
{
int tmptoall=toalltime;
tmpsum=0;
memset(tmptime,0,sizeof(tmptime));
set<node>Q;
for(int j=i;j>=0;j--)
{
if(j-1>=0)
tmptoall-=(cost[j-1]*5);
Q.insert(t[j]);
}
while(tmptoall)
{
node first=*Q.begin();
Q.erase(Q.begin());
tmpsum+=first.fishes;
first.fishes-=first.theMinus;
if(first.fishes<0)
first.fishes=0;
Q.insert(first);
tmptime[first.id]+=5;
tmptoall-=5;
if(tmptoall<5)
tmptoall=0;
}
if(tmpsum>ans)
{
ans=tmpsum;
memcpy(fishBone,tmptime,sizeof(tmptime));
}
}
for(int i=0;i<n;i++)
{
printf("%d%s",fishBone[i],i==n-1?"\n":", ");
}
cout<<"Number of fish expected: "<<ans<<endl;
cout<<endl;
}
return 0;
}1861: Unscrambling Images
#include <iostream>
#include <cstring>
#include <algorithm>
#include <iomanip>
#include <map>
using namespace std;
typedef pair<int,int> pa;
int arr[300],raw[20][20],board[20][20],n,k,kcase;
map<int,int> ma;
void create(int arr[][20],pa le=make_pair(1,1),int len=n,int node=0);
int main(){
ios_base::sync_with_stdio(false);
int times;
cin>>times;
while(times--){
cout<<"Case "<<++kcase<<endl<<endl;
cin>>n;
cin>>k;
for(int i=0,a,b;i<k;++i)
cin>>a>>b,ma.insert(make_pair(a,b));
create(raw);
ma.clear();
cin>>k;
for(int i=0,a,b;i<k;++i)
cin>>a>>b,ma.insert(make_pair(a,b));
create(board);
ma.clear();
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
arr[raw[i][j]]=board[i][j];
for(int i=1,tmp=0;i<=n;++i){
for(int j=1;j<=n;++j)
cout<<setw(4)<<arr[tmp++];
cout<<endl;
}
cout<<endl;
}
return 0;
}
void create(int arr[][20],pa le,int len,int node){
if(ma.find(node)!=ma.end()){
int tmp=ma[node];
for(int i=0;i<len;++i)
for(int j=0;j<len;++j)
arr[le.first+i][le.second+j]=tmp;
}else{
create(arr,le,(len>>1),(node<<2)+1);
create(arr,make_pair(le.first+(len>>1),le.second),(len>>1),(node<<2)+2);
create(arr,make_pair(le.first,(le.second)+(len>>1)),(len>>1),(node<<2)+3);
create(arr,make_pair(le.first+(len>>1),le.second+(len>>1)),(len>>1),(node<<2)+4);
}
}1862: The Same Game
#include <cstdio>
#include <bitset>
#include <iostream>
#include <set>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
typedef long long ll;
const int maxn= 30 +9;
string s[maxn];
int n=10,m=15,vis[maxn][maxn];
struct pn
{
int x,y;
};
void dfs(int x,int y,char c,int& t)
{
if(x<0||x>=n||y<0||y>=m||vis[x][y]) return;
if(s[x][y]!=c) return;
t++;
vis[x][y]=1;
for(int i=-1;i<2;i++){
for(int j=-1;j<2;j++) if(!i^!j){
dfs(x+i,y+j,c,t);
}
}
}
void dfs2(int x,int y,char c)
{
if(x<0||x>=n||y<0||y>=m||vis[x][y]) return;
if(s[x][y]!=c) return;
s[x][y]='.';
vis[x][y]=1;
for(int i=-1;i<2;i++){
for(int j=-1;j<2;j++) if(!i^!j){
dfs2(x+i,y+j,c);
}
}
}
int K;
vector<int> vi;
bool allem(int y)
{
for(int i=0;i<n;i++){
if(s[i][y]!='.')
return false;
}
return true;
}
void smove()
{
//down
for(int j=0;j<m;j++){
for(int i=n-1;i>=0;i--){
if(s[i][j]=='.'){
for(int k=i;k>=0;k--){
if(s[k][j]!='.'){
swap(s[i][j],s[k][j]);
break;
}
}
}
}
}
//left
for(int j=0;j<m;j++){
if(allem(j)){
for(int k=j;k<m;k++){
if(!allem(k)){
for(int i=0;i<n;i++)
swap(s[i][j],s[i][k]);
break;
}
}
}
}
}
int okw()
{
int ans=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++){
if(s[i][j]!='.')
ans++;
}
return ans;
}
int main()
{
int T; cin>>T;
while(T--){
ll fin=0;
for(int i=0;i<n;i++){
cin>>s[i];
}
printf("Game %d:\n\n",++K);
int KK=0;
for(;1;){
vi.clear();
memset(vis,0,sizeof(vis));
int num=0,J=0;
pn p;
char CC;
for(int j=0;j<m;j++)
for(int i=n-1;i>=0;i--) if(!vis[i][j]&&s[i][j]!='.'){
int t=0;
dfs(i,j,s[i][j],t);
J++;
if(t<=1) continue;
vi.push_back(t);
if(t>num){
CC=s[i][j];
p.x=i,p.y=j;
num=t;
}
else if(t==num){
if(j<p.y&&i>p.x){
CC=s[i][j];
p.x=i,p.y=j;
}
}
}
memset(vis,0,sizeof(vis));
if(vi.empty()||okw()==0){
break;
}
dfs2(p.x,p.y,CC);
printf("Move %d at (%d,%d): removed %d balls of color %c, got %lld points.\n",++KK,n-p.x,p.y+1,num,CC,(ll)(num-2)*(num-2));
fin+=(ll)(num-2)*(num-2);
smove();
}
if(!okw()){
fin+=1000;
}
printf("Final score: %lld, with %d balls remaining.\n",fin,okw());
if(K!=n) puts("");
}
return 0;
}1865: Triangle War
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#define LL long long
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define down(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
inline LL read()
{
LL d=0,f=1;char s=getchar();
while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
while(s>='0'&&s<='9'){d=d*10+s-'0';s=getchar();}
return d*f;
}
#define N 18
#define MIN -10
int tri[9]={7,52,152,352,3200,12544,34304,71680,155648};
int m=(1<<18)-1;
int map[11][11]={0};
int pri[4][2]={1,0,0,1,-1,0,0,-1};
int f[(1<<19)+5];
int n;
void getmap()
{
memset(map,0,sizeof(map));
map[1][2]=1;map[1][3]=2;
map[2][3]=3;map[2][4]=4;map[2][5]=5;
map[3][5]=6;map[3][6]=7;
map[4][5]=8;map[4][7]=10;map[4][8]=11;
map[5][6]=9;map[5][8]=12;map[5][9]=13;
map[6][9]=14;map[6][10]=15;
map[7][8]=16;
map[8][9]=17;
map[9][10]=18;
fo(i,1,9)
fo(j,i+1,10)
if(map[i][j])
map[j][i]=map[i][j];
}
int getvalue(int old,int now)
{
int ret=0;
fo(i,0,8)
if((old&tri[i])!=tri[i]&&(now&tri[i])==tri[i])
ret++;
return ret;
}
int calc(int now)
{
if(f[now]!=MIN)return f[now];
int cnt=getvalue(0,now),ma=MIN;
bitset<20>t;t=now;
fo(i,0,17)
if(t[i]==0)
{
t[i]=1;
int ne=t.to_ulong();
int val=getvalue(now,ne);
if(val>0)val+=calc(ne);
else val+=-1*calc(ne);
ma=max(ma,val);
t[i]=0;
}
return f[now]=ma;
}
void solve(int ch)
{
n=read();
int player=1,cnt=0;
bitset<20>t;t.reset();
fo(i,1,n)
{
int x=read(),y=read();
int k=0;
if(map[x][y])
{
// cout<<"B:"<<map[x][y]<<endl;
unsigned long old=t.to_ulong();
t[map[x][y]-1]=1;
unsigned long now=t.to_ulong();
k=getvalue(old,now);
}
if(k)cnt+=player*k;
else player*=-1;
}
unsigned long now=t.to_ulong();
cnt+=player*calc(now);
if(cnt>0)printf("Game %d: A wins.\n",ch);
else printf("Game %d: B wins.\n",ch);
}
int main()
{
getmap();
fill(f,f+(1<<19),-10);
f[m]=0;
int ttttt=read();
fo(i,1,ttttt)solve(i);
return 0;
}1885: 条条大道通罗马
#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int maxn=100005;
const int maxm=400005;
const long long inf=1e20;
int head[maxn];
typedef struct Edge {
int to;
int cost;
int next;
} edge;
edge edges[maxm];
int cnt,inque[maxn];
long long dis[maxn];
int n,m;
void init()
{
memset(head, -1, sizeof(head));
memset(inque, 0, sizeof(inque));
cnt = 0;
}
void add_edge(int from , int to, int cost)
{
edges[cnt].to = to;
edges[cnt].cost = cost;
edges[cnt].next = head[from];
head[from] = cnt++;
}
queue<int> que;
void spfa()
{
while(que.size()) que.pop();
for(int i = 1; i <= n; i++) dis[i] = inf;
dis[1] = 0,inque[1] = 1;
que.push(1);
while(que.size()) {
int u = que.front();
que.pop();
inque[u] = 0;
for(int i = head[u]; i != -1; i = edges[i].next) {
if(dis[edges[i].to] > dis[u] + edges[i].cost) {
dis[edges[i].to] = dis[u] + edges[i].cost;
if(!inque[edges[i].to]) {
que.push(edges[i].to);
inque[edges[i].to] = 1;
}
}
}
}
return ;
}
int main(void)
{
std::ios::sync_with_stdio(false);
while(cin>>n && n) {
cin>>m;
init();
int u,v,w;
for(int i = 0; i < m; i++) {
cin>>u>>v>>w;
add_edge(u,v,-w);
}
spfa();
cout<<-dis[n]<<endl;
}
return 0;
}1886: Phone List
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
struct P{
char s[101];
}a[10001];
bool cmp(P a,P b)///排序
{
if(strcmp(a.s,b.s)>0) return false;
else return true;
}
int main()
{
int t,n;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%s",&a[i].s);
sort(a,a+n,cmp);
int f=0;
for(int i=0;i<n;i++)
{
if(strncmp(a[i].s,a[i+1].s,strlen(a[i].s))==0)
{f=1; break;}
}
if(f) printf("NO\n");
else printf("YES\n");
}
return 0;
}1887: Cuckoo Hashing
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<string>
#include<sstream>
using namespace std;
const int maxn = 10000+5;
int h1[maxn],h2[maxn];
int vis[maxn];
int pos[maxn];
int T,m,n;
int dfs(int a)
{
for(int i = 0;i<2;i++)
{
int tmp;
if(!i)
tmp = h1[a];
else
tmp = h2[a];
if(!vis[tmp])
{ //cout<<a<<' '<<tmp<<' '<<"pos"<<tmp<<' '<<pos[tmp]<<endl;
vis[tmp] = 1;
if(pos[tmp]==-1||dfs(pos[tmp]))
{
pos[tmp] = a;
return 1;
}
}
}
return 0;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
memset(pos,-1,sizeof(pos));
for(int i = 0;i <n ;i++)
{
scanf("%d%d",&h1[i],&h2[i]);
}
int ok = 1;
for(int i = 0; i< n;i++)
{
memset(vis,0,sizeof(vis));
if(!dfs(i))
{
// cout<<i<<endl;
ok = 0;
break;
}
}
if(ok)
{
puts("successful hashing");
}
else
{
puts("rehash necessary");
}
}
return 0;
}1888: Optimal Parking
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main(){
int i,j,n,t,max,min,ans,p;
scanf("%d",&t);
for(i=1;i<=t;i++){
ans=max=0;
min=200;
scanf("%d",&n);
for(j=1;j<=n;j++){
scanf("%d",&p);
if(p>max)max=p;
if(p<min)min=p;
}
ans=2*(max-min);
printf("%d\n",ans);
}
return 0;
}1889: Copying DNA
#include <iostream>
#include <cstring>
#include <algorithm>
#include <bitset>
using namespace std;
const int maxm=20;
int memo[1<<maxm],n,m,times,match(int i,int g,char* str,int e),solve(int found);
char s[maxm],sr[maxm],t[maxm];
int main(){
ios_base::sync_with_stdio(0);
cin>>times;
while(times--){
cin>>s>>t;
m=strlen(s),n=strlen(t);
reverse_copy(s,s+m,sr);
memset(memo,-1,sizeof(int)*(1<<n));
memo[(1<<n)-1]=0;
if(solve(0)==0x3f3f3f3f)
cout<<"impossible\n";
else
cout<<solve(0)<<endl;
}
return 0;
}
int match(int i, int g, char* str, int e){
int longest=0;
for(int k=0,h=0;k<e;++k,h=0){
while(h<g&&k+h<e&&str[k+h]==t[i+h])++h;
longest=max(h,longest);
}
return longest;
}
int solve(int found){
if(memo[found]!=-1)
return memo[found];
char u[maxm]{},ur[maxm]{};
int best=0x3f3f3f3f,last_h=0;
for(int i=0;i<n;++i)
if(found&(1<<i))u[i]=t[i];
reverse_copy(u,u+n,ur);
for(int i=0,g=0,h=0;i<n;++i,g=h=0){
while(i+g<n&&!(found&(1<<i+g)))++g;
if(g==0)
last_h=0;
else{
h=max(max(match(i,g,sr,m),match(i,g,s,m)),max(match(i,g,u,n),match(i,g,ur,n)));
if(h==0)return 0x3f3f3f3f;
if(h>last_h-1)
best=min(best,1+solve(found|((1<<i+h)-1)^((1<<i)-1)));
if(best==0x3f3f3f3f)
break;
last_h=h;
}
}
return memo[found]=best;
}1891: Full Tank?
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int maxm=10010,maxn=1010,maxc=110;
struct Edge{
int v,nt,c;
explicit Edge(int a=0,int b=0,int cc=0):v(a),nt(b),c(cc){};
}edge[maxm<<1];
struct Node{
int cost,city,fuel;
explicit Node(int a=0,int b=0,int c=0):cost(a),city(b),fuel(c){};
bool operator<(const Node& n)const{return cost>n.cost;}
}tmp;
int n,m,fi[maxn],p[maxn],x,y,c,ind,q,s,e,co[maxn][maxc];
bool vis[maxn][maxc];
priority_queue<Node> pq;
inline void addeage(){
edge[ind]=Edge(x,fi[y],c);
fi[y]=ind++;
edge[ind]=Edge(y,fi[x],c);
fi[x]=ind++;
}
int main(){
ios_base::sync_with_stdio(0);
while(cin>>n>>m){
memset(fi,-1,sizeof(int)*(n+1));
for(int i=0;i<n;++i)
cin>>p[i];
for(int i=0;i<m;++i){
cin>>x>>y>>c;
addeage();
}
cin>>q;
while(q--){
cin>>c>>s>>e;
memset(co,0x3f3f3f3f,sizeof(co[0])*(n+1));
memset(vis,0,sizeof(vis[0])*(n+1));
co[s][0]=0;
pq.push(Node(0,s,0));
while(!pq.empty()){
tmp=pq.top();pq.pop();
if(vis[tmp.city][tmp.fuel])
continue;
if(tmp.city==e)
break;
if(tmp.fuel<c&&tmp.cost+p[tmp.city]<co[tmp.city][tmp.fuel+1]){
co[tmp.city][tmp.fuel+1]=tmp.cost+p[tmp.city];
pq.push(Node(tmp.cost+p[tmp.city],tmp.city,tmp.fuel+1));
}
for(int i=fi[tmp.city];i!=-1;i=edge[i].nt)
if(tmp.fuel-edge[i].c>=0&&co[tmp.city][tmp.fuel]<co[edge[i].v][tmp.fuel-edge[i].c]){
co[edge[i].v][tmp.fuel-edge[i].c]=co[tmp.city][tmp.fuel];
pq.push(Node(co[edge[i].v][tmp.fuel-edge[i].c],edge[i].v,tmp.fuel-edge[i].c));
}
vis[tmp.city][tmp.fuel]=true;
}
if(co[e][0]<0x3f3f3f3f)
cout<<co[e][0]<<endl;
else
cout<<"impossible\n";
while(!pq.empty())pq.pop();
}
ind=0;
}
return 0;
}1892: Nested Dolls
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct Doll{
int width,height;
}doll[20005],selected[20005];
bool cmp(Doll a,Doll b){
if(a.width==b.width)
return a.height>b.height; //这里只可用 >，用 < WA了
return a.width<b.width;
}
int main(){
int t,n,cnt;
scanf("%d",&t);
while(t--){
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%d%d",&doll[i].width,&doll[i].height);
sort(doll,doll+n,cmp);
cnt=0;
for(int i=0;i<n;i++){
int left=0,right=cnt,mid;
while(left<right){
mid=(left+right)/2;
if(doll[i].width<=selected[mid].width ||
doll[i].height<=selected[mid].height)
left=mid+1;
else
right=mid;
}
if(left==cnt)
selected[cnt++]=doll[i];
else
selected[left]=doll[i];
}
printf("%d\n",cnt);
}
return 0;
}1897: The price table of the snack store
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long LL;
int L[10005];
LL c[10005],x[10005];
int main()
{
int T;
scanf("%d",&T);
LL sigmax;
while(T--)
{
int k,n,m;
scanf("%d%d%d",&k,&n,&m);
sigmax=0;
for(int i=1;i<=k;i++)
{
scanf("%lld%d",&c[i],&L[i]);
sigmax+=c[i];
}
sigmax=sigmax/(n+(k-1)*m);
for(int i=1;i<=k;i++)
x[L[i]]=(c[i]-sigmax*m)/(n-m);
for(int i=1;i<=k;i++)
{
if(i==1) printf("%lld",x[i]);
else printf(" %lld",x[i]);
}
printf("\n");
}
return 0;
}
扫一扫
395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
