KiritoTRw
GitHub
parent
661cb9622c
commit
3845accd4b
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
const int N = 300+10;
|
||||
int s[N*N],g[N*N];
|
||||
#define _cp(a,b) ((a)<=(b))
|
||||
int _tmp[N*N];
|
||||
int inv(int n,int* a){
|
||||
int l=n>>1,r=n-l,i,j;
|
||||
int ret=(r>1?(inv(l,a)+inv(r,a+l)):0);
|
||||
for (i=j=0;i<=l;_tmp[i+j]=a[i],i++)
|
||||
for (ret+=j;j<r&&(i==l||!_cp(a[i],a[l+j]));_tmp[i+j]=a[l+j],j++);
|
||||
memcpy(a,_tmp,sizeof(int)*n);
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)==1 && n)
|
||||
{
|
||||
int num=0;
|
||||
bool flag=true;
|
||||
for(int i=0;i<n*n;i++)
|
||||
{
|
||||
scanf("%d",&g[i]);
|
||||
if(flag && g[i]!=0)
|
||||
num++;
|
||||
if(g[i]==0)
|
||||
flag=false;
|
||||
}
|
||||
int temp=inv(n*n,g);
|
||||
temp-=num;
|
||||
if(!(n&1))
|
||||
temp+=(n-1-(num/n));
|
||||
if(temp&1)
|
||||
puts("NO");
|
||||
else puts("YES");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 30009
|
||||
#define lc (d<<1)
|
||||
#define rc (d<<1|1)
|
||||
#define mid (l+r>>1)
|
||||
#define inf 0x3f3f3f3f
|
||||
struct Tr{
|
||||
int mx, sum;
|
||||
}tr[N<<4];
|
||||
int n, sun[N], tid[N], top[N], val[N], dep[N], tot, tmp[N], fa[N];
|
||||
vector<int>V[N];
|
||||
int dfs(int u, int f) {
|
||||
int i, v, id = u, mx = 0, c = 1;
|
||||
fa[u] = f;
|
||||
for (i = 0;i < V[u].size();i++) {
|
||||
v = V[u][i];
|
||||
if (v == f) continue;
|
||||
int tm = dfs(v, u);
|
||||
if (tm > mx) mx = tm, id = v;
|
||||
c += tm;
|
||||
}
|
||||
sun[u] = id;
|
||||
return c;
|
||||
}
|
||||
void dfs1(int u, int d, int Top) {
|
||||
int i, v;
|
||||
dep[u] = d, tid[u] = ++tot, top[u] = Top;
|
||||
if (tid[sun[u]] == -1) dfs1(sun[u], d+1, Top);
|
||||
for (i = 0;i < V[u].size();i++) {
|
||||
v = V[u][i];
|
||||
if (tid[v] != -1) continue;
|
||||
dfs1(v, d+1, v);
|
||||
}
|
||||
}
|
||||
void Push(int d) {
|
||||
tr[d].sum = tr[lc].sum+tr[rc].sum;
|
||||
tr[d].mx = max(tr[lc].mx, tr[rc].mx);
|
||||
}
|
||||
void build(int d, int l, int r) {
|
||||
if (l == r) {
|
||||
tr[d].mx = tr[d].sum = val[l];
|
||||
return;
|
||||
}
|
||||
build(lc, l, mid), build(rc, mid+1, r);
|
||||
Push(d);
|
||||
}
|
||||
void update(int d, int l, int r, int pos, int v) {
|
||||
if (l == r && pos == l) {
|
||||
tr[d].mx = tr[d].sum = v;
|
||||
return;
|
||||
}
|
||||
if (pos <= mid) update(lc, l, mid, pos, v);
|
||||
else update(rc, mid+1, r, pos, v);
|
||||
Push(d);
|
||||
}
|
||||
int query(int d, int l, int r, int L, int R, int k) {
|
||||
if (l == L && r == R) {
|
||||
if (k) return tr[d].mx;
|
||||
return tr[d].sum;
|
||||
}
|
||||
if (R <= mid) return query(lc, l, mid, L, R, k);
|
||||
else if (L > mid) return query(rc, mid+1, r, L, R, k);
|
||||
else {
|
||||
if (k) return max(query(lc, l, mid, L, mid, k), query(rc, mid+1, r, mid+1, R, k));
|
||||
else return query(lc, l, mid, L, mid, k)+query(rc, mid+1, r, mid+1, R, k);
|
||||
}
|
||||
}
|
||||
int M(int u, int v, int k) {
|
||||
int re = 0, tm;
|
||||
if (k) re = -inf;
|
||||
while (top[u] != top[v]) {
|
||||
if (dep[top[u]] < dep[top[v]]) swap(u, v);
|
||||
tm = query(1, 1, tot, tid[top[u]], tid[u], k);
|
||||
if (k) re = max(tm, re);
|
||||
else re += tm;
|
||||
u = fa[top[u]];
|
||||
}
|
||||
if (tid[u] > tid[v]) swap(u, v);
|
||||
tm = query(1, 1, tot, tid[u], tid[v], k);
|
||||
if (k) re = max(tm, re);
|
||||
else re += tm;
|
||||
return re;
|
||||
}
|
||||
int main() {
|
||||
int i, j, u, v, m;
|
||||
char w[10];
|
||||
while (~scanf("%d", &n)) {
|
||||
for (i = 1;i <= n;i++) V[i].clear();
|
||||
for (i = 1;i < n;i++) {
|
||||
scanf("%d%d", &u, &v);
|
||||
V[u].push_back(v), V[v].push_back(u);
|
||||
}
|
||||
memset(tid, -1, sizeof(tid));
|
||||
tot = 0;
|
||||
for (i = 1;i <= n;i++) scanf("%d", &tmp[i]);
|
||||
dfs(1, -1);
|
||||
dfs1(1, 0, 1);
|
||||
for (i = 1;i <= n;i++) val[tid[i]] = tmp[i];
|
||||
build(1, 1, tot);
|
||||
scanf("%d", &m);
|
||||
while (m--) {
|
||||
scanf("%s%d%d", w, &u, &v);
|
||||
if (w[0] == 'C') {
|
||||
update(1, 1, tot, tid[u], v);
|
||||
}else if (w[1] == 'M') {
|
||||
printf("%d\n", M(u, v, 1));
|
||||
}else printf("%d\n", M(u, v, 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int a[110], b[110];
|
||||
int dp[110][10100][2];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
int n, m, k;
|
||||
int sum = 0;
|
||||
int num = 0;
|
||||
scanf("%d%d%d", &n, &m, &k);
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d%d", &a[i], &b[i]);
|
||||
if(a[i] > k) continue;
|
||||
a[i]++;
|
||||
sum += b[i];
|
||||
a[++num] = a[i];
|
||||
b[num] = b[i];
|
||||
}
|
||||
n = num;
|
||||
memset(dp, -1, sizeof(dp));
|
||||
for(int i = 0; i <= n; i++)
|
||||
{
|
||||
dp[i][0][0] = 1;
|
||||
dp[i][0][1] = 0;
|
||||
}
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
for(int j = sum; j >= b[i]; j--)
|
||||
{
|
||||
dp[i][j][0] = dp[i-1][j][0];
|
||||
dp[i][j][1] = dp[i-1][j][1];
|
||||
if(dp[i-1][j-b[i]][1] == -1) continue;
|
||||
if(dp[i-1][j-b[i]][1] + a[i] <= k)
|
||||
{
|
||||
if(dp[i][j][0] == -1 || dp[i-1][j-b[i]][0] < dp[i][j][0] ||
|
||||
(dp[i-1][j-b[i]][0] == dp[i][j][0] && dp[i-1][j-b[i]][1] + a[i] < dp[i][j][1]))
|
||||
{
|
||||
dp[i][j][0] = dp[i-1][j-b[i]][0];
|
||||
dp[i][j][1] = dp[i-1][j-b[i]][1] + a[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(dp[i][j][0] == -1 || dp[i-1][j-b[i]][0] + 1 < dp[i][j][0] ||
|
||||
(dp[i-1][j-b[i]][0] + 1 == dp[i][j][0] && a[i] < dp[i][j][1]))
|
||||
{
|
||||
dp[i][j][0] = dp[i-1][j-b[i]][0] + 1;
|
||||
dp[i][j][1] = a[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int rmax = 0;
|
||||
for(int j = 0; j <= sum; j++)
|
||||
if(dp[n][j][0] != -1 && dp[n][j][0] <= m && j > rmax)
|
||||
{
|
||||
rmax = j;
|
||||
}
|
||||
printf("%d\n", rmax);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#define maxn 300001
|
||||
#define eps 1e-6
|
||||
using namespace std;
|
||||
int n;
|
||||
int m;
|
||||
int len[maxn];
|
||||
int vis[maxn];
|
||||
int mx[maxn][24];
|
||||
int pre[maxn];
|
||||
int search(int l,int r)
|
||||
{
|
||||
int t=l;
|
||||
while(l<r)
|
||||
{
|
||||
int mid=l+r>>1;
|
||||
if(pre[mid]<t)
|
||||
{
|
||||
l=mid+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
r=mid;
|
||||
}
|
||||
}
|
||||
return l;
|
||||
}
|
||||
void init_rmq()
|
||||
{
|
||||
int i,j;
|
||||
int k=(int)(log2(n)+eps);
|
||||
for(i=1; i<=n; i++)
|
||||
{
|
||||
mx[i][0]=len[i];
|
||||
}
|
||||
for(i=1; i<=k; i++)
|
||||
{
|
||||
for(j=1; j<=n; j++)
|
||||
{
|
||||
mx[j][i]=mx[j][i-1];
|
||||
if(j+(1<<(i-1))<=n)
|
||||
{
|
||||
mx[j][i]=max(mx[j][i],mx[j+(1<<(i-1))][i-1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int rmq(int l,int r)
|
||||
{
|
||||
int k=(int)(log2(r-l+1)+eps);
|
||||
return max(mx[l][k],mx[r-(1<<k)+1][k]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
memset(len,0,sizeof(len));
|
||||
memset(vis,-1,sizeof(vis));
|
||||
memset(pre,-1,sizeof(pre));
|
||||
for(i=1; i<=n; i++)
|
||||
{
|
||||
int temp;
|
||||
scanf("%d",&temp);
|
||||
if(vis[temp]==-1)
|
||||
{
|
||||
pre[i]=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
pre[i]=vis[temp]+1;
|
||||
}
|
||||
pre[i]=max(pre[i],pre[i-1]);
|
||||
len[i]=i-pre[i]+1;
|
||||
vis[temp]=i;
|
||||
}
|
||||
init_rmq();
|
||||
scanf("%d",&m);
|
||||
while(m--)
|
||||
{
|
||||
int l,r;
|
||||
scanf("%d %d",&l,&r);
|
||||
if(l>r) swap(l,r);
|
||||
int t=search(l,r);
|
||||
if(t==r)
|
||||
{
|
||||
printf("%d\n",t-l+1);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%d\n",max(t-l,rmq(t,r)));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
const int MAXN=100110;
|
||||
const int MAXM=4000110;
|
||||
const int INF=0x3f3f3f3f;
|
||||
struct Node
|
||||
{
|
||||
int to,next,cap;
|
||||
}edge[MAXM];
|
||||
int tol;
|
||||
int head[MAXN];
|
||||
int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
|
||||
void init()
|
||||
{
|
||||
tol=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
}
|
||||
void addedge(int u,int v,int w,int rw=0)
|
||||
{
|
||||
edge[tol].to=v;edge[tol].cap=w;edge[tol].next=head[u];head[u]=tol++;
|
||||
edge[tol].to=u;edge[tol].cap=rw;edge[tol].next=head[v];head[v]=tol++;
|
||||
}
|
||||
int sap(int start,int end,int nodenum)
|
||||
{
|
||||
memset(dis,0,sizeof(dis));
|
||||
memset(gap,0,sizeof(gap));
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u=pre[start]=start,maxflow=0,aug=-1;
|
||||
gap[0]=nodenum;
|
||||
while(dis[start]<nodenum)
|
||||
{
|
||||
loop:
|
||||
for(int &i=cur[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].to;
|
||||
if(edge[i].cap&&dis[u]==dis[v]+1)
|
||||
{
|
||||
if(aug==-1||aug>edge[i].cap)
|
||||
aug=edge[i].cap;
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==end)
|
||||
{
|
||||
maxflow+=aug;
|
||||
for(u=pre[u];v!=start;v=u,u=pre[u])
|
||||
{
|
||||
edge[cur[u]].cap-=aug;
|
||||
edge[cur[u]^1].cap+=aug;
|
||||
}
|
||||
aug=-1;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
int mindis=nodenum;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].to;
|
||||
if(edge[i].cap&&mindis>dis[v])
|
||||
{
|
||||
cur[u]=i;
|
||||
mindis=dis[v];
|
||||
}
|
||||
}
|
||||
if((--gap[dis[u]])==0)break;
|
||||
gap[dis[u]=mindis+1]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
int num[1025];
|
||||
int a[11];
|
||||
int bit[11];
|
||||
int main()
|
||||
{
|
||||
bit[0]=1;
|
||||
for(int i=1;i<=10;i++)bit[i]=bit[i-1]*2;
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
init();
|
||||
memset(num,0,sizeof(num));
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
int tmp=0;
|
||||
for(int j=0;j<m;j++){scanf("%d",&a[j]);tmp+=a[j]*bit[j];}
|
||||
num[tmp]++;
|
||||
}
|
||||
int start=0,end=1024+m+1,nodenum=2014+m+2;
|
||||
for(int i=0;i<1024;i++)
|
||||
{
|
||||
if(num[i]==0)continue;
|
||||
addedge(start,i+1,num[i]);
|
||||
for(int j=0;j<10;j++)
|
||||
if(i&bit[j] )
|
||||
addedge(i+1,1024+j+1,INF);
|
||||
}
|
||||
int tmp;
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d",&tmp);
|
||||
addedge(i+1024,end,tmp);
|
||||
}
|
||||
if(sap(start,end,nodenum)==n)printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define maxn 100005
|
||||
struct Node
|
||||
{
|
||||
int l,r;
|
||||
int max_gold;
|
||||
}tree[maxn*4];
|
||||
struct Box
|
||||
{
|
||||
int height;
|
||||
int gold;
|
||||
int li;
|
||||
int id;
|
||||
}box[maxn];
|
||||
int N,ans,cnt;
|
||||
void build(int id,int l,int r)
|
||||
{
|
||||
tree[id].l=l;
|
||||
tree[id].r=r;
|
||||
tree[id].max_gold=0;
|
||||
if(r>l)
|
||||
{
|
||||
int mid=(l+r)/2;
|
||||
build(id*2,l,mid);
|
||||
build(id*2+1,mid+1,r);
|
||||
}
|
||||
}
|
||||
void update(int id,int idx,int val)
|
||||
{
|
||||
if(tree[id].l==tree[id].r)
|
||||
{
|
||||
tree[id].max_gold=max(tree[id].max_gold,val);
|
||||
return;
|
||||
}
|
||||
int mid=(tree[id].l+tree[id].r)/2;
|
||||
if(idx<=mid)
|
||||
{
|
||||
update(id*2,idx,val);
|
||||
}
|
||||
else
|
||||
{
|
||||
update(id*2+1,idx,val);
|
||||
}
|
||||
tree[id].max_gold=max(tree[id*2].max_gold,tree[id*2+1].max_gold);
|
||||
}
|
||||
int query(int id,int l,int r)
|
||||
{
|
||||
if(tree[id].l==l&&tree[id].r==r)
|
||||
{
|
||||
return tree[id].max_gold;
|
||||
}
|
||||
int mid=(tree[id].l+tree[id].r)/2;
|
||||
if(r<=mid)
|
||||
{
|
||||
return query(id*2,l,r);
|
||||
}
|
||||
else if(l>mid)
|
||||
{
|
||||
return query(id*2+1,l,r);
|
||||
}
|
||||
else
|
||||
{
|
||||
return max(query(id*2,l,mid),query(id*2+1,mid+1,r));
|
||||
}
|
||||
}
|
||||
int cmp1(Box a,Box b)
|
||||
{
|
||||
return a.height<b.height;
|
||||
}
|
||||
int cmp2(Box a,Box b)
|
||||
{
|
||||
return a.id<b.id;
|
||||
}
|
||||
void lisan()
|
||||
{
|
||||
sort(box,box+N,cmp1);
|
||||
cnt=0;
|
||||
box[0].li=0;
|
||||
for(int i=1;i<N;i++)
|
||||
{
|
||||
if(box[i].height!=box[i-1].height)
|
||||
{
|
||||
cnt++;
|
||||
box[i].li=cnt;
|
||||
}
|
||||
else
|
||||
{
|
||||
box[i].li=cnt;
|
||||
}
|
||||
}
|
||||
sort(box,box+N,cmp2);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
lisan();
|
||||
build(1,0,cnt);
|
||||
ans=0;
|
||||
for(int i=0;i<N;i++)
|
||||
{
|
||||
if(box[i].li==0)
|
||||
{
|
||||
update(1,0,box[i].gold);
|
||||
ans=max(ans,box[i].gold);
|
||||
}
|
||||
else
|
||||
{
|
||||
int t=query(1,0,box[i].li-1);
|
||||
update(1,box[i].li,t+box[i].gold);
|
||||
ans=max(ans,t+box[i].gold);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&N)==1)
|
||||
{
|
||||
for(int i=0;i<N;i++)
|
||||
{
|
||||
scanf("%d%d",&box[i].height,&box[i].gold);
|
||||
box[i].id=i;
|
||||
}
|
||||
solve();
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<stdio.h>
|
||||
typedef __int64 ll;
|
||||
ll mod=100000000;
|
||||
ll m[205];
|
||||
ll eular(ll n)
|
||||
{
|
||||
ll i,ret=1;
|
||||
for(i=2;i*i<=n;i++)
|
||||
{
|
||||
if(n%i==0)
|
||||
{
|
||||
n=n/i;
|
||||
ret=ret*(i-1);
|
||||
while(n%i==0)
|
||||
{
|
||||
n=n/i;
|
||||
ret=ret*i;
|
||||
}
|
||||
}
|
||||
if(n==1)
|
||||
break;
|
||||
}
|
||||
if(n>1)
|
||||
ret=ret*(n-1);
|
||||
return ret;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
ll i;
|
||||
m[1]=mod;
|
||||
for(i=2;i<=204;i++)
|
||||
m[i]=eular(m[i-1]);
|
||||
}
|
||||
ll power(ll a,ll b,ll c)
|
||||
{
|
||||
ll res=1;
|
||||
while(b)
|
||||
{
|
||||
if(b%2==1)
|
||||
res=res*a%c;
|
||||
a=(a%c)*(a%c)%c;
|
||||
b=b/2;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
ll a,k,i,ans;
|
||||
init();
|
||||
while(scanf("%I64d%I64d",&a,&k)!=EOF)
|
||||
{
|
||||
ans=a;
|
||||
if(a==0&&k%2==0)
|
||||
{
|
||||
printf("1\n");
|
||||
continue;
|
||||
}
|
||||
for(i=k;i>=2;i--)
|
||||
{
|
||||
ans=ans%m[i];
|
||||
if(ans==0)
|
||||
ans=m[i];
|
||||
ans=power(a,ans,m[i-1]);
|
||||
}
|
||||
printf("%I64d\n",ans%mod);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
int sum[32], re, num;
|
||||
int main()
|
||||
{
|
||||
int ca, n, k, i, j, po;
|
||||
scanf("%d", &ca);
|
||||
while(ca--)
|
||||
{
|
||||
scanf("%d%d", &n, &k);
|
||||
memset(sum, 0, sizeof(sum));
|
||||
for(i=0; i<n; i++)
|
||||
{
|
||||
scanf("%d", &num);
|
||||
po=0;
|
||||
while(num)
|
||||
{
|
||||
sum[po++]+=num&1;
|
||||
num>>=1;
|
||||
}
|
||||
}
|
||||
re=0;
|
||||
for(i=0; i<32; i++)
|
||||
re+=(sum[i]%(k+1));
|
||||
puts(re==0?"Li wins":"Fernandes wins");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 99999999
|
||||
using namespace std;
|
||||
const int MAX=500000+10;
|
||||
char s[MAX*2];
|
||||
int p[MAX*2],sum[MAX],val[27];
|
||||
int per[MAX],pos[MAX];
|
||||
int main(){
|
||||
int n;
|
||||
cin>>n;
|
||||
while(n--){
|
||||
for(int i=0;i<26;++i)scanf("%d",&val[i]);
|
||||
scanf("%s",s);
|
||||
int len=strlen(s),id=0,ans=-INF,temp=0;
|
||||
for(int i=1;i<=len;++i)sum[i]=sum[i-1]+val[s[i-1]-'a'];
|
||||
for(int i=len;i>=0;--i){
|
||||
s[i+i+2]=s[i];
|
||||
s[i+i+1]='#';
|
||||
}
|
||||
s[0]='*';
|
||||
for(int i=2;i<len+len+1;++i){
|
||||
if(p[id]+id>i)p[i]=min(p[2*id-i],p[id]+id-i);
|
||||
else p[i]=1;
|
||||
while(s[i-p[i]] == s[i+p[i]])++p[i];
|
||||
if(id+p[id]<i+p[i])id=i;
|
||||
if(i-p[i] == 0)per[p[i]-1]=n+1;
|
||||
if(i+p[i] == len+len+2)pos[p[i]-1]=n+1;
|
||||
}
|
||||
for(int i=1;i<len;++i){
|
||||
if(per[i] == n+1)temp+=sum[i];
|
||||
if(pos[len-i] == n+1)temp+=sum[len]-sum[i];
|
||||
if(temp>ans)ans=temp;
|
||||
temp=0;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#define MAXN 11
|
||||
#define MOD 40007
|
||||
using namespace std;
|
||||
const int n=8;
|
||||
int a[MAXN][MAXN];
|
||||
int x;
|
||||
int DX[MAXN][MAXN]=
|
||||
{
|
||||
{0,1,1,0,1,0,0,0},
|
||||
{1,0,0,1,0,1,0,0},
|
||||
{1,0,0,1,0,0,1,0},
|
||||
{0,1,1,0,0,0,0,1},
|
||||
{1,0,0,0,0,1,1,0},
|
||||
{0,1,0,0,1,0,0,1},
|
||||
{0,0,1,0,1,0,0,1},
|
||||
{0,0,0,1,0,1,1,0}
|
||||
};
|
||||
void print(int a[MAXN][MAXN])
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<n;j++) cout<<a[i][j]<<" ";
|
||||
cout<<endl;
|
||||
}
|
||||
}
|
||||
void mult(int x[MAXN][MAXN],int y[MAXN][MAXN],int z[MAXN][MAXN])
|
||||
{
|
||||
int t[MAXN][MAXN];
|
||||
memset(t,0,sizeof(t));
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++)
|
||||
for(int k=0;k<n;k++) t[i][k]=(t[i][k]+x[i][j]*y[j][k])%MOD;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++) z[i][j]=t[i][j];
|
||||
}
|
||||
void calc(int x[MAXN][MAXN],int y,int z[MAXN][MAXN])
|
||||
{
|
||||
int t[MAXN][MAXN];
|
||||
int a[MAXN][MAXN];
|
||||
memset(a,0,sizeof(a));
|
||||
memset(t,0,sizeof(t));
|
||||
for(int i=0;i<n;i++) a[i][i]=1;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++) t[i][j]=x[i][j];
|
||||
if(y%2==1)
|
||||
mult(a,t,a);
|
||||
y=y/2;
|
||||
while(y>0)
|
||||
{
|
||||
mult(t,t,t);
|
||||
if(y%2==1) mult(a,t,a);
|
||||
y=y/2;
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++) z[i][j]=a[i][j];
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++) a[i][j]=DX[i][j];
|
||||
calc(a,x,a);
|
||||
cout<<a[0][0]<<" "<<(a[3][0]+a[5][0]+a[6][0])%MOD<<" "<<(a[1][0]+a[2][0]+a[4][0])%MOD<<" "<<a[7][0]<<endl;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int casen;
|
||||
scanf("%d",&casen);
|
||||
while(casen--)
|
||||
{
|
||||
cin>>x;
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 40;
|
||||
const int maxpot = maxn*maxn*2;
|
||||
const int maxm = maxpot*10;
|
||||
const int INFI = 99999999;
|
||||
const int dx[4] = {0,1,0,-1};
|
||||
const int dy[4] = {1,0,-1,0};
|
||||
int a[maxn][maxn];
|
||||
int idx[maxn][maxn];
|
||||
int L[maxpot],R[maxpot];
|
||||
int head[maxpot],dep[maxpot],lis[maxpot];
|
||||
int ne[maxm],pot[maxm],flow[maxm];
|
||||
int S,T,tot,n,m;
|
||||
void addedge(int a,int b,int c)
|
||||
{
|
||||
pot[++tot] = b; ne[tot] = head[a];
|
||||
head[a] = tot; flow[tot] = c;
|
||||
}
|
||||
void connect(int a,int b,int c)
|
||||
{
|
||||
addedge(a,b,c);
|
||||
addedge(b,a,0);
|
||||
}
|
||||
bool bfs()
|
||||
{
|
||||
for (int i=0;i<=T;i++) dep[i] = 0;
|
||||
int h=1,t=1;
|
||||
lis[1] = S;
|
||||
dep[S] = 1;
|
||||
while ( h<=t )
|
||||
{
|
||||
int v = lis[h];
|
||||
for (int e=head[v];e!=-1;e=ne[e])
|
||||
if ( flow[e]>0 && dep[pot[e]]==0 )
|
||||
{
|
||||
dep[pot[e]] = dep[v] + 1;
|
||||
lis[++t] = pot[e];
|
||||
}
|
||||
h++;
|
||||
}
|
||||
return dep[T]>0;
|
||||
}
|
||||
int findpath(int v,int tmpflow)
|
||||
{
|
||||
if ( v==T ) return tmpflow;
|
||||
int rec = 0,tmp;
|
||||
for (int e=head[v];e!=-1;e=ne[e])
|
||||
if ( flow[e]>0 && dep[pot[e]]==dep[v]+1 )
|
||||
{
|
||||
tmp = findpath(pot[e],min(tmpflow,flow[e]));
|
||||
tmpflow -= tmp; rec += tmp;
|
||||
flow[e] -= tmp; flow[e^1] += tmp;
|
||||
if ( tmpflow==0 ) break;
|
||||
}
|
||||
dep[v] = 0;
|
||||
return rec;
|
||||
}
|
||||
int dinic()
|
||||
{
|
||||
int ret = 0;
|
||||
while ( bfs() )
|
||||
ret += findpath(S,INFI);
|
||||
return ret;
|
||||
}
|
||||
void build_graph()
|
||||
{
|
||||
int sum = 0;
|
||||
int tx,ty;
|
||||
int v,u;
|
||||
for (int i=0;i<n;i++)
|
||||
for (int j=0;j<m;j++)
|
||||
if ( a[i][j]!=-1 )
|
||||
idx[i][j] = ++sum;
|
||||
S = 0;
|
||||
for (int i=1;i<=sum;i++)
|
||||
{
|
||||
L[i] = i;
|
||||
R[i] = i + sum;
|
||||
}
|
||||
T = 2 * sum + 1;
|
||||
memset(head,-1,sizeof(head));
|
||||
tot = -1;
|
||||
for (int i=0;i<n;i++)
|
||||
for (int j=0;j<m;j++)
|
||||
if ( a[i][j]!=-1 )
|
||||
{
|
||||
v = idx[i][j];
|
||||
if ( a[i][j]!=0 )
|
||||
connect(L[v],R[v],a[i][j]);
|
||||
else
|
||||
connect(L[v],R[v],INFI);
|
||||
for (int t=0;t<4;t++)
|
||||
{
|
||||
tx = i + dx[t];
|
||||
ty = j + dy[t];
|
||||
if ( tx<0 || ty<0 || tx>=n || ty>=m ) continue;
|
||||
u = idx[tx][ty];
|
||||
if ( a[tx][ty]!=-1 )
|
||||
connect(R[v],L[u],INFI);
|
||||
}
|
||||
if ( a[i][j]==0 )
|
||||
connect(S,L[v],INFI);
|
||||
if ( i==0 || j==0 || i==n-1 || j==m-1 )
|
||||
connect(R[v],T,INFI);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test;
|
||||
scanf("%d",&test);
|
||||
for (int cas=1;cas<=test;cas++)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for (int i=0;i<n;i++)
|
||||
for (int j=0;j<m;j++)
|
||||
scanf("%d",&a[i][j]);
|
||||
build_graph();
|
||||
int ans = dinic();
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#define maxn 1010
|
||||
using namespace std;
|
||||
int cor[maxn];
|
||||
struct Tr{
|
||||
int a, b;
|
||||
} r[maxn];
|
||||
bool cmp(const Tr &a, const Tr &b){
|
||||
return (a.a<b.a || a.a==b.a&&a.b<b.b);
|
||||
}
|
||||
bool equ(const Tr &a, const Tr &b){
|
||||
return (a.a==b.a && a.b==b.b);
|
||||
}
|
||||
int n;
|
||||
void init(){
|
||||
scanf("%d", &n);
|
||||
for (int i=0; i<n; i++) scanf("%d", &r[i].a);
|
||||
for (int i=0; i<n; i++) scanf("%d", &r[i].b);
|
||||
sort(r, r+n, cmp);
|
||||
}
|
||||
void solve(){
|
||||
int i=0, last=0; memset(cor, 0, sizeof cor);
|
||||
int ret = 0;
|
||||
while (i<n){
|
||||
int cnt=1;
|
||||
while (i+1!=n && equ(r[i], r[i+1])){
|
||||
i++; cnt++;
|
||||
}
|
||||
while (last!=r[i].a){
|
||||
last++;
|
||||
cor[last] = max(cor[last], cor[last-1]);
|
||||
}
|
||||
int tmp = (n+1 - (r[i].a+r[i].b) + 1);
|
||||
int maxcor = min(tmp, cnt);
|
||||
cor[last+tmp] = max(cor[last+tmp], cor[last] + maxcor);
|
||||
ret = max(ret, cor[last+tmp]);
|
||||
i++;
|
||||
}
|
||||
printf("%d\n", ret);
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
int test;
|
||||
scanf("%d", &test);
|
||||
while (test--){
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define maxn 409
|
||||
int S,T;
|
||||
struct edge
|
||||
{
|
||||
int v,flow,cost;
|
||||
edge *next,*opp;
|
||||
}A[500009],*adj[maxn];
|
||||
#define NEW() &A[++ANS]
|
||||
int ANS;
|
||||
inline void addedge(int u,int v,int flow,int cost)
|
||||
{
|
||||
edge *ptr=NEW();
|
||||
ptr->v=v;
|
||||
ptr->flow=flow;
|
||||
ptr->cost=cost;
|
||||
ptr->next=adj[u]->next;
|
||||
ptr->opp=&A[ANS^1];
|
||||
adj[u]->next=ptr;
|
||||
}
|
||||
#define Inf 1000000000
|
||||
int q[1000009],d[maxn];
|
||||
bool vis[maxn];
|
||||
edge *pre[maxn];
|
||||
bool spfa()
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(int i=S;i<=T;i++)
|
||||
d[i]=Inf;
|
||||
int head=0,tail=1,u,v;
|
||||
q[0]=S;
|
||||
d[S]=0;
|
||||
while(head!=tail)
|
||||
{
|
||||
u=q[head++];
|
||||
vis[u]=false;
|
||||
for(edge *ptr=adj[u]->next;ptr!=NULL;ptr=ptr->next)
|
||||
{
|
||||
v=ptr->v;
|
||||
if(ptr->flow&&d[v]>d[u]+ptr->cost)
|
||||
{
|
||||
d[v]=d[u]+ptr->cost;
|
||||
pre[v]=ptr;
|
||||
if(!vis[v])
|
||||
{
|
||||
vis[v]=true;
|
||||
q[tail++]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return d[T]!=Inf;
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int mincost=0;
|
||||
while(spfa())
|
||||
{
|
||||
edge *ptr;
|
||||
int low=Inf;
|
||||
for(int i=T;i!=S;)
|
||||
{
|
||||
ptr=pre[i];
|
||||
low=min(low,ptr->flow);
|
||||
i=ptr->opp->v;
|
||||
}
|
||||
for(int i=T;i!=S;)
|
||||
{
|
||||
ptr=pre[i];
|
||||
ptr->flow-=low;
|
||||
ptr->opp->flow+=low;
|
||||
i=ptr->opp->v;
|
||||
}
|
||||
if(d[T]>=0)
|
||||
break;
|
||||
mincost+=low*d[T];
|
||||
}
|
||||
return mincost;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int Q;
|
||||
scanf("%d",&Q);
|
||||
while(Q--)
|
||||
{
|
||||
int s,t,v,n;
|
||||
S=0;
|
||||
scanf("%d",&n);
|
||||
ANS=-1;
|
||||
for(int i=0;i<406;i++)
|
||||
{
|
||||
adj[i]=new edge();
|
||||
adj[i]->next=NULL;
|
||||
}
|
||||
for(int k=1;k<=n;k++)
|
||||
{
|
||||
scanf("%d%d%d",&s,&t,&v);
|
||||
s++;
|
||||
t++;
|
||||
addedge(s,t+1,1,-v);
|
||||
addedge(t+1,s,0,v);
|
||||
T=max(T,t+1);
|
||||
}
|
||||
for(int i=S;i<T;i++)
|
||||
{
|
||||
addedge(i,i+1,2,0);
|
||||
addedge(i+1,i,0,0);
|
||||
}
|
||||
printf("%d\n",-solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define MIN(a,b) (a)>(b)?(b):(a)
|
||||
const int INF = 0x3f3f3f3f ;
|
||||
int T ,N ,M , K ,Sr,Sc,Er,Ec;
|
||||
char maze[55][55] ;
|
||||
unsigned int MA ;
|
||||
int dr[4] = {-1, 1, 0, 0} ;
|
||||
int dc[4] = {0,0,-1,1} ;
|
||||
int key[51][51] ;
|
||||
queue<int> que ;
|
||||
bool in[55][55][1<<5] ;
|
||||
int dis[55][55][1<<5] ;
|
||||
bool relax(int r,int c ,int s ,int nr,int nc , int ns, int d){
|
||||
if(dis[nr][nc][ns] > dis[r][c][s] + d){
|
||||
dis[nr][nc][ns] = dis[r][c][s] + d ;
|
||||
return true;
|
||||
}
|
||||
return false ;
|
||||
}
|
||||
void spfa(){
|
||||
MA = (1 << K) - 1 ;
|
||||
while(!que.empty()) que.pop() ;
|
||||
for(int i=1;i<=N;i++){
|
||||
for(int j=1;j<=M;j++){
|
||||
for(int k=0;k<=MA;k++){
|
||||
in[i][j][k] = 0 ;
|
||||
dis[i][j][k] = INF ;
|
||||
}
|
||||
}
|
||||
}
|
||||
dis[Sr][Sc][0] = 0 ;
|
||||
in[Sr][Sc][0] = 1 ;
|
||||
que.push(Sr); que.push(Sc); que.push(0);
|
||||
while(!que.empty()){
|
||||
int r = que.front() ; que.pop() ;
|
||||
int c = que.front() ; que.pop() ;
|
||||
int s = que.front() ; que.pop() ;
|
||||
in[r][c][s] = 0 ;
|
||||
for(int i=0;i<4;i++){
|
||||
int nr = r + dr[i] ;
|
||||
int nc = c + dc[i] ,ns;
|
||||
if(nr<1||nc<1||nr>N||nc>M||maze[nr][nc]=='#') continue ;
|
||||
ns = (s | key[nr][nc]) ;
|
||||
if(maze[nr][nc]=='.'){
|
||||
if(relax(r,c,s, nr,nc,ns,0) && !in[nr][nc][ns]){
|
||||
in[nr][nc][ns] = 1 ;
|
||||
que.push(nr) ; que.push(nc) ;que.push(ns) ;
|
||||
}
|
||||
}
|
||||
else if(maze[nr][nc]>='1' && maze[nr][nc]<='9'){
|
||||
if(relax(r,c,s, nr,nc,ns , maze[nr][nc]-'0') && !in[nr][nc][ns]){
|
||||
in[nr][nc][ns] = 1 ;
|
||||
que.push(nr) ; que.push(nc) ;que.push(ns) ;
|
||||
}
|
||||
}
|
||||
else{
|
||||
int a = maze[nr][nc] - 'A' ;
|
||||
if((s&(1<<a)) != 0){
|
||||
if(relax(r,c,s, nr,nc,ns ,0) && !in[nr][nc][ns]){
|
||||
in[nr][nc][ns] = 1 ;
|
||||
que.push(nr) ; que.push(nc) ;que.push(ns) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = INF ;
|
||||
for(int i=0;i<=MA;i++){
|
||||
if(ans > dis[Er][Ec][i]){
|
||||
ans = dis[Er][Ec][i] ;
|
||||
}
|
||||
}
|
||||
if(ans == INF){
|
||||
ans = -1 ;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main(){
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d%d%d",&N,&M,&K);
|
||||
for(int i=1;i<=N;i++){
|
||||
scanf("%s",maze[i]+1);
|
||||
for(int j=1;j<=M;j++){
|
||||
if(maze[i][j]=='S'){
|
||||
Sr = i ; Sc = j ;
|
||||
maze[i][j] = '.' ;
|
||||
}
|
||||
if(maze[i][j] == 'T'){
|
||||
Er = i ; Ec = j ;
|
||||
maze[i][j] = '.' ;
|
||||
}
|
||||
}
|
||||
}
|
||||
memset(key , 0 ,sizeof(key));
|
||||
for(int i=0;i<K;i++){
|
||||
int a ,b ;
|
||||
scanf("%d %d",&a , &b);
|
||||
key[a][b] = (key[a][b] | (1<<i)) ;
|
||||
}
|
||||
spfa() ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define N 201
|
||||
using namespace std;
|
||||
char Map[N][N];
|
||||
int f[2][N][N], n, m;
|
||||
void init(int x, int y) {
|
||||
for (int i = 0; i < n; ++i) {
|
||||
scanf("%s", Map[i]);
|
||||
}
|
||||
for (int i = 0; i < n; ++i) {
|
||||
for (int j = 0; j < m; ++j) {
|
||||
f[0][i][j] = -1;
|
||||
}
|
||||
}
|
||||
f[0][x - 1][y - 1] = 0;
|
||||
}
|
||||
struct Queue {
|
||||
int id[N], w[N], left, right;
|
||||
void init() {
|
||||
left = right = 0;
|
||||
}
|
||||
bool empty() {
|
||||
return left == right;
|
||||
}
|
||||
void insert(int pos, int v, int len) {
|
||||
if (left < right && abs(id[left] - pos) > len) {
|
||||
++left;
|
||||
}
|
||||
if (v == -1) {
|
||||
return;
|
||||
}
|
||||
while (left < right) {
|
||||
int p = right - 1;
|
||||
if (w[p] + abs(id[p] - pos) > v) {
|
||||
break;
|
||||
}
|
||||
--right;
|
||||
}
|
||||
id[right] = pos, w[right] = v;
|
||||
++right;
|
||||
}
|
||||
int left_id() {
|
||||
return id[left];
|
||||
}
|
||||
} que;
|
||||
void DP(int k, int len, int d) {
|
||||
switch (d) {
|
||||
case 1:
|
||||
for (int j = 0; j < m; ++j) {
|
||||
que.init();
|
||||
for (int i = n - 1; i >= 0; --i) {
|
||||
que.insert(i, f[1 - k][i][j], len);
|
||||
if (Map[i][j] == 'x') {
|
||||
que.init();
|
||||
}
|
||||
if (que.empty()) {
|
||||
f[k][i][j] = -1;
|
||||
} else {
|
||||
f[k][i][j] = f[1 - k][que.left_id()][j] + que.left_id() - i;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
for (int j = 0; j < m; ++j) {
|
||||
que.init();
|
||||
for (int i = 0; i < n; ++i) {
|
||||
que.insert(i, f[1 - k][i][j], len);
|
||||
if (Map[i][j] == 'x') {
|
||||
que.init();
|
||||
}
|
||||
if (que.empty()) {
|
||||
f[k][i][j] = -1;
|
||||
} else {
|
||||
f[k][i][j] = f[1 - k][que.left_id()][j] + i - que.left_id();
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
for (int i = 0; i < n; ++i) {
|
||||
que.init();
|
||||
for (int j = m - 1; j >= 0; --j) {
|
||||
que.insert(j, f[1 - k][i][j], len);
|
||||
if (Map[i][j] == 'x') {
|
||||
que.init();
|
||||
}
|
||||
if (que.empty()) {
|
||||
f[k][i][j] = -1;
|
||||
} else {
|
||||
f[k][i][j] = f[1 - k][i][que.left_id()] + que.left_id() - j;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (int i = 0; i < n; ++i) {
|
||||
que.init();
|
||||
for (int j = 0; j < m; ++j) {
|
||||
que.insert(j, f[1 - k][i][j], len);
|
||||
if (Map[i][j] == 'x') {
|
||||
que.init();
|
||||
}
|
||||
if (que.empty()) {
|
||||
f[k][i][j] = -1;
|
||||
} else {
|
||||
f[k][i][j] = f[1 - k][i][que.left_id()] + j - que.left_id();
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
int x, y, tot, T;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d%d%d%d%d", &n, &m, &x, &y, &tot);
|
||||
init(x, y);
|
||||
for (int i = 1; i <= tot; ++i) {
|
||||
int len, d;
|
||||
scanf("%d%d", &len, &d);
|
||||
DP(i % 2, len, d);
|
||||
}
|
||||
int ans = 0;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
for (int j = 0; j < m; ++j) {
|
||||
ans = (ans < f[tot % 2][i][j] ? f[tot % 2][i][j] : ans);
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#define MAXN 210
|
||||
#define EPS 1e-3
|
||||
using namespace std;
|
||||
int n;
|
||||
struct Edge{
|
||||
int v,next;
|
||||
Edge(){}
|
||||
Edge(int _v,int _next):v(_v),next(_next){}
|
||||
}edge[MAXN*MAXN];
|
||||
int head[MAXN], size;
|
||||
inline void initial(){
|
||||
memset(head,-1,sizeof(int)*(n+2));
|
||||
size = 0;
|
||||
}
|
||||
inline void add_edge(int u,int v){
|
||||
edge[size] = Edge(v,head[u]);
|
||||
head[u] = size ++;
|
||||
}
|
||||
int belong[MAXN];
|
||||
bool vis[MAXN];
|
||||
int depth;
|
||||
int bcnt;
|
||||
int dfn[MAXN], low[MAXN];
|
||||
int stack[MAXN], tail ;
|
||||
inline void Tarjan(int u){
|
||||
dfn[u] = low[u] = depth ++;
|
||||
vis[u] = 1;
|
||||
stack[++tail] = u;
|
||||
for(int i = head[u];i != -1;i = edge[i].next){
|
||||
int v = edge[i].v;
|
||||
if(dfn[v] == -1){
|
||||
Tarjan(v);
|
||||
if(low[u] > low[v])
|
||||
low[u] = low[v];
|
||||
}else if(vis[v] && low[u] > dfn[v]){
|
||||
low[u] = dfn[v];
|
||||
}
|
||||
}
|
||||
if(low[u] == dfn[u]){
|
||||
bcnt ++;
|
||||
int j;
|
||||
do{
|
||||
j = stack[tail--];
|
||||
vis[j] = 0;
|
||||
belong[j] = bcnt;
|
||||
}while(j != u);
|
||||
}
|
||||
}
|
||||
double x[MAXN], y[MAXN];
|
||||
inline double Cal(int i,int j){
|
||||
return (x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]);
|
||||
}
|
||||
inline bool can(){
|
||||
int N = n/2;
|
||||
for(int i = 1;i <= N; ++i)
|
||||
if(belong[i] == belong[i+N]) return false;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int N;
|
||||
while(scanf("%d",&N) != EOF){
|
||||
n = 2*N;
|
||||
for(int i = 1;i <= N; ++i)
|
||||
scanf("%lf%lf%lf%lf",&x[i],&y[i],&x[i+N],&y[i+N]);
|
||||
double right = 10000.0*10000.0, left = 0.0, mid;
|
||||
while(right - left >= EPS){
|
||||
mid = (right + left)/2.0;
|
||||
initial();
|
||||
for(int i = 1;i < n; ++i)
|
||||
for(int j = i + 1;j <= n; ++j){
|
||||
if(Cal(i,j) < mid){
|
||||
int u, v;
|
||||
if(i <= N) u = i + N;
|
||||
else u = i - N;
|
||||
if(j <= N) v = j + N;
|
||||
else v = j - N;
|
||||
add_edge(i,v);
|
||||
add_edge(j,u);
|
||||
}
|
||||
}
|
||||
tail = depth = bcnt = 0;
|
||||
memset(vis,0,sizeof(bool)*(n+2));
|
||||
memset(dfn,-1,sizeof(int)*(n+2));
|
||||
memset(low,0,sizeof(int)*(n+2));
|
||||
for(int i = 1;i <= n; ++i)
|
||||
if(dfn[i] == -1) Tarjan(i);
|
||||
if(can()) left = mid;
|
||||
else right = mid;
|
||||
}
|
||||
printf("%.2lf\n",sqrt(left)/2.0);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#define eps 1e-7
|
||||
#define LL long long
|
||||
using namespace std;
|
||||
LL fac[21]={1};
|
||||
LL stir1[21][21];
|
||||
int main(){
|
||||
for(int i=1;i<21;i++)
|
||||
fac[i]=fac[i-1]*i;
|
||||
for(int i=1;i<=20;i++){
|
||||
stir1[i][0]=0;
|
||||
stir1[i][i]=1;
|
||||
for(int j=1;j<i;j++)
|
||||
stir1[i][j]=stir1[i-1][j-1]+(i-1)*stir1[i-1][j];
|
||||
}
|
||||
int t,n,k;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d",&n,&k);
|
||||
if(n==1||k==0){
|
||||
printf("0.0000\n");
|
||||
continue;
|
||||
}
|
||||
LL sum=0;
|
||||
for(int i=1;i<=k;i++)
|
||||
sum+=stir1[n][i]-stir1[n-1][i-1];
|
||||
printf("%.4f\n",(double)sum/fac[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int maxn =1010;
|
||||
struct matrix{
|
||||
int x,y;
|
||||
};
|
||||
matrix ma[maxn];
|
||||
int flag[maxn];
|
||||
int main(){
|
||||
for(int n,cases=1;cin>>n && n!=0;cases++){
|
||||
for(int i=0;i<n;i++)
|
||||
cin>>ma[i].x>>ma[i].y;
|
||||
cout<<(cases==1?"":"\n")<<"Case "<<cases<<":\n";
|
||||
for(int i=0;i<n;i++){
|
||||
int min,num=0;
|
||||
memset(flag,0,sizeof(flag));
|
||||
for(int j=0;j<n;j++){
|
||||
if(ma[j].x>ma[i].x && ma[j].y>ma[i].y){
|
||||
flag[j]=1;
|
||||
num++;
|
||||
min=j;
|
||||
}
|
||||
}
|
||||
if(num==0)
|
||||
cout<<"-1 -1\n";
|
||||
else if(num==1)
|
||||
cout<<ma[min].x<<" "<<ma[min].y<<"\n";
|
||||
else{
|
||||
for(int j=0;j<n;j++){
|
||||
if(flag[j]==1 && ma[j].x<ma[min].x){
|
||||
min=j;
|
||||
}
|
||||
}
|
||||
num=0;
|
||||
for(int j=0;j<n;j++){
|
||||
if(flag[j]==1 && ma[j].x==ma[min].x){
|
||||
num++;
|
||||
flag[j]=2;
|
||||
}
|
||||
}
|
||||
if(num ==1)
|
||||
cout<<ma[min].x<<" "<<ma[min].y<<"\n";
|
||||
else{
|
||||
for(int j=0;j<n;j++){
|
||||
if(flag[j]==2 && ma[j].y<ma[min].y)
|
||||
min=j;
|
||||
}
|
||||
cout<<ma[min].x<<" "<<ma[min].y<<"\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<string>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
map<int,set<int> > m;
|
||||
map<int,set<int> >::iterator mi;
|
||||
set<int>::iterator si;
|
||||
set<int>s;
|
||||
map<int,int>yy;
|
||||
int n;
|
||||
int tx,ty;
|
||||
char c[11];
|
||||
int temp,t2;
|
||||
int tt;
|
||||
int main()
|
||||
{
|
||||
int cas=1;
|
||||
while(cin>>n)
|
||||
{
|
||||
if(n==0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if(cas!=1)
|
||||
{
|
||||
cout<<endl;
|
||||
}
|
||||
printf("Case %d:\n",cas++);
|
||||
m.clear();
|
||||
s.clear();
|
||||
yy.clear();
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%s",c);
|
||||
scanf("%d%d",&tx,&ty);
|
||||
if(c[0]=='a')
|
||||
{
|
||||
if(yy.find(ty) == yy.end())
|
||||
{
|
||||
yy[ty] = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
yy[ty]++;
|
||||
}
|
||||
if(s.find(tx)==s.end())
|
||||
{
|
||||
s.insert(tx);
|
||||
}
|
||||
mi = m.find(tx);
|
||||
if(mi != m.end())
|
||||
{
|
||||
si = mi -> second.find(ty);
|
||||
if(si!=mi -> second.end())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
mi->second.insert(ty);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m[tx].insert(ty);
|
||||
}
|
||||
}
|
||||
else if(c[0]=='f')
|
||||
{
|
||||
if(yy.upper_bound(ty) == yy.end())
|
||||
{
|
||||
printf("-1\n");
|
||||
continue;
|
||||
}
|
||||
tt = tx;
|
||||
while(true)
|
||||
{
|
||||
if(s.empty())
|
||||
{
|
||||
printf("-1\n");
|
||||
break;
|
||||
}
|
||||
si = s.upper_bound(tt);
|
||||
if(si!=s.end())
|
||||
{
|
||||
temp = *si;
|
||||
tt = temp;
|
||||
if(m[temp].empty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
si = m[temp].upper_bound(ty);
|
||||
if(si != m[temp].end())
|
||||
{
|
||||
t2 = *si;
|
||||
printf("%d %d\n",temp,t2);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("-1\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(c[0]=='r')
|
||||
{
|
||||
m[tx].erase(ty);
|
||||
if(m[tx].empty())
|
||||
{
|
||||
s.erase(tx);
|
||||
}
|
||||
if(!--yy[ty])
|
||||
{
|
||||
yy.erase(ty);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define eps (1e-9)
|
||||
double r,v,w,X,E;
|
||||
bool zero(double t)
|
||||
{
|
||||
return fabs(t)<eps;
|
||||
}
|
||||
double jifen(double t)
|
||||
{
|
||||
return (t*v*sqrt(r*r+t*t*v*v)+r*r*log(v*(t*v+sqrt(r*r+t*t*v*v))))/(2*v);
|
||||
}
|
||||
bool ok(double mid)
|
||||
{
|
||||
double tmp=X*sqrt(r*r*w*w+v*v)*(jifen(mid)-jifen(0));
|
||||
if(tmp+eps>E)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%lf%lf%lf%lf%lf",&r,&w,&v,&X,&E)!=EOF)
|
||||
{
|
||||
if(zero(r)&&zero(w)&&zero(v)&&zero(X)&&zero(E))
|
||||
break;
|
||||
double left=0,right=30*24*3600.0,ans=-1,mid;
|
||||
int cas=100;
|
||||
if(zero(r))
|
||||
{
|
||||
printf("%.4lf\n",sqrt(2*E/v/v));
|
||||
continue;
|
||||
}
|
||||
while(cas--)
|
||||
{
|
||||
mid=(left+right)/2;
|
||||
if(ok(mid))
|
||||
{
|
||||
ans=mid;
|
||||
right=mid;
|
||||
}
|
||||
else
|
||||
{
|
||||
left=mid;
|
||||
}
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<cmath>
|
||||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#define eps 1e-8
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
const int N=1000;
|
||||
struct Point{double x, y;}p[N];
|
||||
double ans[2*N];
|
||||
long long C(int a,int b){
|
||||
long long ans=1;
|
||||
for(int i=0;i<b;i++) ans*=(a-i);
|
||||
for(int i=2;i<=b;i++) ans/=i;
|
||||
return ans;
|
||||
}
|
||||
int main(){
|
||||
int t,n;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
long long res=0;
|
||||
for(int i=0;i<n;i++){
|
||||
for(int j=0;j<n;j++){
|
||||
if(j==i) continue;
|
||||
double tmp=atan2(p[j].y-p[i].y,p[j].x-p[i].x);
|
||||
if(tmp<=-eps) tmp+=2*pi;
|
||||
j<i?ans[j]=tmp:ans[j-1]=tmp;
|
||||
}
|
||||
sort(ans,ans+n-1);
|
||||
int k=1;
|
||||
long long re2=0;
|
||||
for(int j=0;j<n-1;j++)
|
||||
ans[j+n-1]=ans[j]+2*pi;
|
||||
for(int j=0;j<n-1;j++){
|
||||
while(fabs(ans[k]-ans[j])-pi<0) k++;
|
||||
if(k-j-1>=2) re2+=C(k-j-1,2);
|
||||
}
|
||||
res+=C(n-1,3)-re2;
|
||||
}
|
||||
printf("%I64d\n",C(n,4)-res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#include"iostream"
|
||||
#include"cstdio"
|
||||
#include"cmath"
|
||||
#include"cstring"
|
||||
using namespace std;
|
||||
const int N=155;
|
||||
int n,m,q,s;
|
||||
int dp[N][N][9][9],le[N][N],rg[N][N],sum[N][N];
|
||||
int lowbit[N];
|
||||
inline int max(int a,int b){
|
||||
return a>b?a:b;
|
||||
}
|
||||
void RMQ()
|
||||
{
|
||||
int j1,j2,row,col;
|
||||
int mx=int(log(1.0*n)/log(2.0));
|
||||
int my=int(log(1.0*m)/log(2.0));
|
||||
for(j1=0;j1<=mx;j1++)
|
||||
{
|
||||
for(j2=0;j2<=my;j2++)
|
||||
{
|
||||
if(!j1 && !j2) continue;
|
||||
for(row=1;row+(1<<j1)-1<=n;row++)
|
||||
{
|
||||
for(col=1;col+(1<<j2)-1<=m;col++)
|
||||
{
|
||||
if(!j1)
|
||||
dp[row][col][j1][j2]=max(dp[row][col][j1][j2-1],dp[row][col+(1<<(j2-1))][j1][j2-1]);
|
||||
else
|
||||
dp[row][col][j1][j2]=max(dp[row][col][j1-1][j2],dp[row+(1<<(j1-1))][col][j1-1][j2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int power[N];
|
||||
inline int query(int x1,int y1,int x2,int y2)
|
||||
{
|
||||
int kx=power[x2-x1+1];
|
||||
int ky=power[y2-y1+1];
|
||||
int m1=dp[x1][y1][kx][ky];
|
||||
int m2=dp[x2-(1<<kx)+1][y1][kx][ky];
|
||||
int m3=dp[x1][y2-(1<<ky)+1][kx][ky];
|
||||
int m4=dp[x2-(1<<kx)+1][y2-(1<<ky)+1][kx][ky];
|
||||
return max(max(m1,m2),max(m3,m4));
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i,l,temp;
|
||||
for(i=0;i<=150;i++) power[i]=log(double(i))/log(2.0);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
temp=0;
|
||||
for(l=1;l<=m;l++)
|
||||
{
|
||||
scanf("%d",&dp[i][l][0][0]);
|
||||
temp+=dp[i][l][0][0];
|
||||
sum[i][l]=sum[i-1][l]+temp;
|
||||
}
|
||||
}
|
||||
for(i=1;i<=n;i++) {le[i][0]=1;rg[i][m+1]=m;}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(l=1;l<=m;l++)
|
||||
{
|
||||
if(dp[i][l][0][0]==-1) le[i][l]=l+1;
|
||||
else le[i][l]=le[i][l-1];
|
||||
}
|
||||
for(l=m;l>=1;l--)
|
||||
{
|
||||
if(dp[i][l][0][0]==-1) rg[i][l]=l-1;
|
||||
else rg[i][l]=rg[i][l+1];
|
||||
}
|
||||
}
|
||||
RMQ();
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,Case;
|
||||
int i,l;
|
||||
int up;
|
||||
int x1,y1,x2,y2,lmax,rmin;
|
||||
int t,temp,ans;
|
||||
cin>>T;
|
||||
for(i=1;i<=150;i++) lowbit[i]=i&(-i);
|
||||
for(Case=1;Case<=T;Case++)
|
||||
{
|
||||
if(Case>1) printf("\n");
|
||||
printf("Case %d:\n",Case);
|
||||
scanf("%d%d%d%d",&n,&m,&q,&s);
|
||||
init();
|
||||
while(q--)
|
||||
{
|
||||
ans=0;
|
||||
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
|
||||
for(l=y1;l<=y2;l++)
|
||||
{
|
||||
up=x1;
|
||||
lmax=y1;
|
||||
rmin=y2;
|
||||
for(i=x1;i<=x2;i++)
|
||||
{
|
||||
if(le[i][l]==l+1) {up=i+1;lmax=y1;rmin=y2;continue;}
|
||||
if(lmax<le[i][l]) lmax=le[i][l];
|
||||
if(rmin>rg[i][l]) rmin=rg[i][l];
|
||||
temp=query(up,lmax,i,rmin);
|
||||
t=(s-1)*temp+sum[i][rmin]-sum[i][lmax-1]-sum[up-1][rmin]+sum[up-1][lmax-1];
|
||||
if(ans<t) ans=t;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#define inf 99999999
|
||||
using namespace std;
|
||||
int map[305][305];
|
||||
int mark[305];
|
||||
void floyd(int k,int n)
|
||||
{
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if(map[i][j]>map[i][k]+map[k][j])
|
||||
map[i][j]=map[i][k]+map[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,q;
|
||||
int cas=1;
|
||||
while(scanf("%d%d%d",&n,&m,&q))
|
||||
{
|
||||
if(n==0&&m==0&&q==0)
|
||||
break;
|
||||
int i,j;
|
||||
memset(mark,0,sizeof(mark));
|
||||
for(i=0;i<=n;i++)
|
||||
for(j=0;j<=n;j++)
|
||||
map[i][j]=(i==j?0:inf);
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
int u,v,w;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
if(w<map[u][v])
|
||||
map[u][v]=w;
|
||||
}
|
||||
if(cas!=1)
|
||||
printf("\n");
|
||||
printf("Case %d:\n",cas++);
|
||||
for(i=0;i<q;i++)
|
||||
{
|
||||
int f;
|
||||
scanf("%d",&f);
|
||||
if(f==0)
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
if(mark[t])
|
||||
printf("ERROR! At point %d\n",t);
|
||||
else
|
||||
{
|
||||
mark[t]=1;
|
||||
floyd(t,n);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int u,v;
|
||||
scanf("%d%d",&u,&v);
|
||||
if(!mark[u]||!mark[v])
|
||||
printf("ERROR! At path %d to %d\n",u,v);
|
||||
else if(map[u][v]>=inf)
|
||||
printf("No such path\n");
|
||||
else
|
||||
printf("%d\n",map[u][v]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define MAXD 210
|
||||
int N, g[MAXD][MAXD], f[MAXD][MAXD], a[MAXD];
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
scanf("%d", &N);
|
||||
for(i = 1; i <= N; i ++)
|
||||
scanf("%d", &a[i]);
|
||||
for(i = 1; i <= N; i ++)
|
||||
for(j = 1; j <= N; j ++)
|
||||
scanf("%d", &g[i][j]); }
|
||||
int can(int i, int j, int k)
|
||||
{
|
||||
if(!f[i][k] || !f[k][j])
|
||||
return 0;
|
||||
return g[i][k] || g[j][k];
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, k, d, ans = 0;
|
||||
for(i = 1; i <= N; i ++)
|
||||
g[i][0] = g[i][N + 1] = 1, g[0][i] = g[N + 1][i] = 0;
|
||||
for(i = 0; i < N + 1; i ++)
|
||||
f[i][i + 1] = 1;
|
||||
for(d = 2; d <= N; d ++)
|
||||
for(i = 0; (j = i + d) <= N + 1; i ++)
|
||||
{
|
||||
for(k = i + 1; k < j; k ++)
|
||||
if(can(i, j, k))
|
||||
{
|
||||
f[i][j] = 1;
|
||||
break;
|
||||
}
|
||||
if(k == j) f[i][j] = 0;
|
||||
}
|
||||
for(i = 1; i <= N; i ++)
|
||||
if(f[0][i] && f[i][N + 1])
|
||||
ans = std::max(ans, a[i]);
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
int main() {
|
||||
int t, tt;
|
||||
scanf("%d", &t);
|
||||
for(tt = 1; tt <= t; tt ++)
|
||||
{
|
||||
init();
|
||||
printf("Case %d: ", tt);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define HASH 100007
|
||||
#define MAXD 100010
|
||||
#define INF 0x3f3f3f3f
|
||||
int N, M, pre[65][MAXD], a[10][10];
|
||||
char op[65][MAXD], g[10][10];
|
||||
struct HashMap
|
||||
{
|
||||
int head[HASH], size, next[MAXD], st[MAXD], dif[MAXD], col[MAXD], dp[MAXD];
|
||||
void init()
|
||||
{
|
||||
memset(head, -1, sizeof(head)), size = 0;
|
||||
}
|
||||
void push(int _st, int _dif, int _col, int _dp, int id, int p, char ch)
|
||||
{
|
||||
int i, h = ((_st << 6) + _col + 2000 + _dif) % HASH;
|
||||
for(i = head[h]; i != -1; i = next[i])
|
||||
if(st[i] == _st && dif[i] == _dif && col[i] == _col)
|
||||
{
|
||||
dp[i] += _dp;
|
||||
return ;
|
||||
}
|
||||
st[size] = _st, dif[size] = _dif, col[size] = _col, dp[size] = _dp;
|
||||
pre[id][size] = p, op[id][size] = ch;
|
||||
next[size] = head[h], head[h] = size ++;
|
||||
}
|
||||
}hm[2];
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
scanf("%d%d", &N, &M);
|
||||
for(i = 0; i < N; i ++) scanf("%s", g[i]);
|
||||
for(i = 0; i < N; i ++)
|
||||
for(j = 0; j < M; j ++) scanf("%d", &a[i][j]);
|
||||
}
|
||||
int code[10], h[10];
|
||||
inline void decode(int *code, int m, int st)
|
||||
{
|
||||
for(int i = m - 1; i >= 0; i --) code[i] = st & 7, st >>= 3;
|
||||
}
|
||||
inline int encode(int *code, int m)
|
||||
{
|
||||
int i, st = 0, cnt = -1;
|
||||
memset(h, -1, sizeof(h));
|
||||
for(i = 0; i < m; i ++)
|
||||
{
|
||||
if(h[code[i]] == -1) h[code[i]] = ++ cnt;
|
||||
st = st << 3 | h[code[i]];
|
||||
}
|
||||
return st;
|
||||
}
|
||||
void dp(int i, int j, int c, int cur)
|
||||
{
|
||||
int k;
|
||||
for(k = 0; k < hm[cur].size; k ++)
|
||||
{
|
||||
int col = hm[cur].col[k], u = i ? (col >> j & 1) == c : 0, l = j ? (col >> j - 1 & 1) == c : 0, lu = i && j ? (col >> M) == c : 0;
|
||||
if(u && l && lu) continue;
|
||||
if(i == N - 1 && j == M - 1 && !u && !l && lu) continue;
|
||||
decode(code, M, hm[cur].st[k]);
|
||||
if(i && !u)
|
||||
{
|
||||
int t, s1 = 0, s2 = 0;
|
||||
for(t = 0; t < M; t ++)
|
||||
{
|
||||
if(code[t] == code[j]) ++ s1;
|
||||
if((col >> t & 1) != c) ++ s2;
|
||||
}
|
||||
if(s1 == 1)
|
||||
{
|
||||
if(s2 > 1) continue;
|
||||
if(i < N - 1 || j < M - 2) continue;
|
||||
}
|
||||
}
|
||||
if(l && u)
|
||||
{
|
||||
if(code[j] != code[j - 1])
|
||||
for(int t = 0, x = code[j]; t < M; t ++)
|
||||
if(code[t] == x) code[t] = code[j - 1];
|
||||
}
|
||||
else if(l && !u) code[j] = code[j - 1];
|
||||
else if(!l && !u) code[j] = M;
|
||||
if(col & 1 << j) col |= 1 << M;
|
||||
else col &= ~(1 << M);
|
||||
if(c) col |= 1 << j;
|
||||
else col &= ~(1 << j);
|
||||
hm[cur ^ 1].push(encode(code, M), hm[cur].dif[k] + (c ? a[i][j] : -a[i][j]), col, hm[cur].dp[k], i * M + j, k, c ? 'x' : 'o');
|
||||
}
|
||||
}
|
||||
void print(int k)
|
||||
{
|
||||
int i, j;
|
||||
for(i = N - 1; i >= 0; i --)
|
||||
for(j = M - 1; j >= 0; j --)
|
||||
g[i][j] = op[i * M + j][k], k = pre[i * M + j][k];
|
||||
for(i = 0; i < N; i ++) printf("%s\n", g[i]);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, k, cur = 0, ans = 0, min = INF;
|
||||
hm[0].init();
|
||||
hm[0].push(0, 0, 0, 1, 0, 0, 0);
|
||||
for(i = 0; i < N; i ++)
|
||||
for(j = 0; j < M; j ++)
|
||||
{
|
||||
hm[cur ^ 1].init();
|
||||
if(g[i][j] != 'x') dp(i, j, 0, cur);
|
||||
if(g[i][j] != 'o') dp(i, j, 1, cur);
|
||||
cur ^= 1;
|
||||
}
|
||||
for(i = 0; i < hm[cur].size; i ++)
|
||||
{
|
||||
int s1 = 0;
|
||||
memset(h, 0, sizeof(h));
|
||||
decode(code, M, hm[cur].st[i]);
|
||||
for(j = 0; j < M; j ++) if(!h[code[j]]) ++ s1, h[code[j]] = 1;
|
||||
if(s1 <= 2)
|
||||
{
|
||||
if(std::abs(hm[cur].dif[i]) < min)
|
||||
min = std::abs(hm[cur].dif[i]), ans = hm[cur].dp[i], k = i;
|
||||
else if(std::abs(hm[cur].dif[i]) == min)
|
||||
ans += hm[cur].dp[i];
|
||||
}
|
||||
}
|
||||
if(min == INF) printf("0 0\n");
|
||||
else
|
||||
{
|
||||
printf("%d %d\n", min, ans);
|
||||
print(k);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, tt;
|
||||
scanf("%d", &t);
|
||||
for(tt = 1; tt <= t; tt ++)
|
||||
{
|
||||
init();
|
||||
printf("Case %d: ", tt);
|
||||
solve();
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 205;
|
||||
#define LL long long
|
||||
typedef struct
|
||||
{
|
||||
LL x1,y1;
|
||||
LL x2,y2;
|
||||
LL sum;
|
||||
LL v;
|
||||
}Node;
|
||||
Node T[N];
|
||||
LL n;
|
||||
bool cmp(Node a,Node b)
|
||||
{
|
||||
return a.v<b.v;
|
||||
}
|
||||
void Cover(LL x1,LL y1,LL x2,LL y2,LL k,LL c)
|
||||
{
|
||||
while(k<n&&(x1>=T[k].x2||x2<=T[k].x1||y1>=T[k].y2||y2<=T[k].y1)) k++;
|
||||
if(k>=n)
|
||||
{
|
||||
T[c].sum+=(x2-x1)*(y2-y1)*T[c].v;
|
||||
return;
|
||||
}
|
||||
if(x1<T[k].x1)
|
||||
{
|
||||
Cover(x1,y1,T[k].x1,y2,k+1,c);
|
||||
x1=T[k].x1;
|
||||
}
|
||||
if(x2>T[k].x2)
|
||||
{
|
||||
Cover(T[k].x2,y1,x2,y2,k+1,c);
|
||||
x2=T[k].x2;
|
||||
}
|
||||
if(y1<T[k].y1)
|
||||
{
|
||||
Cover(x1,y1,x2,T[k].y1,k+1,c);
|
||||
y1=T[k].y1;
|
||||
}
|
||||
if(y2>T[k].y2)
|
||||
{
|
||||
Cover(x1,T[k].y2,x2,y2,k+1,c);
|
||||
y2=T[k].y2;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL i,k=1,t;
|
||||
scanf("%I64d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
memset(T,0,sizeof(T));
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
T[i].v=0;
|
||||
scanf("%I64d%I64d%I64d%I64d%I64d",&T[i].x1,&T[i].y1,&T[i].x2,&T[i].y2,&T[i].v);
|
||||
T[i].sum=0;
|
||||
}
|
||||
stable_sort(T,T+n,cmp);
|
||||
for(i=n-1;i>=0;i--)
|
||||
Cover(T[i].x1,T[i].y1,T[i].x2,T[i].y2,i+1,i);
|
||||
LL ans=0;
|
||||
for(i=0;i<n;i++)
|
||||
ans+=T[i].sum;
|
||||
printf("Case %I64d: %I64d\n",k++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN=10010;
|
||||
int F[MAXN];
|
||||
int num[MAXN];
|
||||
int mo[MAXN];
|
||||
int n;
|
||||
void init()
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
F[i]=-1;
|
||||
num[i]=1;
|
||||
mo[i]=0;
|
||||
}
|
||||
}
|
||||
int find(int x)
|
||||
{
|
||||
if(F[x]==-1)return x;
|
||||
int t=F[x];
|
||||
F[x]=find(F[x]);
|
||||
mo[x]+=mo[t];
|
||||
return F[x];
|
||||
}
|
||||
void bing(int a,int b)
|
||||
{
|
||||
int t1=find(a);
|
||||
int t2=find(b);
|
||||
if(t1!=t2)
|
||||
{
|
||||
F[t1]=t2;
|
||||
num[t2]+=num[t1];
|
||||
mo[t1]=1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m;
|
||||
int T;
|
||||
char str[10];
|
||||
int a,b;
|
||||
int iCase=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d",&n,&m);
|
||||
init();
|
||||
printf("Case %d:\n",iCase);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%s",&str);
|
||||
if(str[0]=='T')
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
bing(a,b);
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&a);
|
||||
int t=find(a);
|
||||
printf("%d %d %d\n",t,num[t],mo[a]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int size = 111111;
|
||||
typedef long long ll;
|
||||
typedef pair<int,int> pii;
|
||||
ll gcd(ll a, ll b){
|
||||
return b? gcd(b, a%b):a;
|
||||
}
|
||||
char ch[100];
|
||||
ll a, b, c, d, n,t;
|
||||
void get(ll &a, ll &b){
|
||||
n = strlen(ch);
|
||||
ll aa = 0, bb = 1, cc = 0, dd = 1, f = 0;
|
||||
for(int i = 0; i < n && ch[i] != '[';i++){
|
||||
if(ch[i] == '.'){
|
||||
f = 1;
|
||||
continue;
|
||||
}
|
||||
aa = 10 * aa + ch[i] - '0';
|
||||
if(f)
|
||||
bb *= 10;
|
||||
}
|
||||
f = gcd(aa, bb);
|
||||
aa /= f;
|
||||
bb /= f;
|
||||
for(int i = 0; i < n; i++)
|
||||
if(ch[i] == '['){
|
||||
for(int j = i+1; ch[j] != ']'; j++){
|
||||
cc = cc * 10 + ch[j] - '0';
|
||||
dd *= 10;
|
||||
}
|
||||
dd--;
|
||||
for(int j = i -1; ch[j] != '.';j--)
|
||||
dd *= 10;
|
||||
break;
|
||||
}
|
||||
f = gcd(cc, dd);
|
||||
cc /= f;
|
||||
dd /= f;
|
||||
f = gcd(bb,dd);
|
||||
b = bb/f*dd;
|
||||
aa = dd/f*aa +bb/f*cc;
|
||||
a = aa;
|
||||
}
|
||||
int work(ll a, ll b, ll c, ll d, ll p){
|
||||
ll x = a *p / b + 1;
|
||||
ll y = c *p /d;
|
||||
if(c*p%d == 0)
|
||||
y--;
|
||||
if(x <= y)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cin >> t;
|
||||
for(int ca = 1; ca <= t; ca++){
|
||||
cin >> ch;
|
||||
get(a,b);
|
||||
cin >> ch;
|
||||
get(c,d);
|
||||
ll low = 1;
|
||||
while(work(a,b,c,d,low) == 0)
|
||||
low++;
|
||||
ll x = a * low / b + 1;
|
||||
printf("Case %d: %I64d/%I64d\n", ca, x, low);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#define MAXN 60
|
||||
int trans[] = {0, 2, 1, 4, 3};
|
||||
int dx[] = {0, -1, 1, 0, 0}, dy[] = {0, 0, 0, -1, 1};
|
||||
int ex[][9] =
|
||||
{
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, -1, -1, -1, -2, -2, -2, -2, -2},
|
||||
{0, 1, 1, 1, 2, 2, 2, 2, 2},
|
||||
{0, -1, 0, 1, -2, -1, 0, 1, 2},
|
||||
{0, -1, 0, 1, -2, -1, 0, 1, 2}
|
||||
};
|
||||
int ey[][9] =
|
||||
{
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, -1, 0, 1, -2, -1, 0, 1, 2},
|
||||
{0, -1, 0, 1, -2, -1, 0, 1, 2},
|
||||
{0, -1, -1, -1, -2, -2, -2, -2, -2},
|
||||
{0, 1, 1, 1, 2, 2, 2, 2, 2}
|
||||
};
|
||||
struct Monster
|
||||
{
|
||||
int x, y, d;
|
||||
}mon[MAXN];
|
||||
char b[MAXN];
|
||||
int N, M, K, sx, sy, tx, ty, g[MAXN][MAXN], del[MAXN][MAXN], vis[MAXN][MAXN];
|
||||
struct Point
|
||||
{
|
||||
int x, y, t;
|
||||
Point(){}
|
||||
Point(int _x, int _y, int _t) : x(_x), y(_y), t(_t){}
|
||||
};
|
||||
inline int inside(int x, int y)
|
||||
{
|
||||
return x >= 1 && x <= N && y >= 1 && y <= M;
|
||||
}
|
||||
void moveall()
|
||||
{
|
||||
int i, x, y;
|
||||
for(i = 0; i < K; i ++)
|
||||
{
|
||||
x = mon[i].x + dx[mon[i].d], y = mon[i].y + dy[mon[i].d];
|
||||
if(inside(x, y) && g[x][y]) mon[i].x = x, mon[i].y = y;
|
||||
else mon[i].d = trans[mon[i].d];
|
||||
}
|
||||
}
|
||||
void delblock()
|
||||
{
|
||||
int i, j, x, y;
|
||||
for(i = 1; i <= N; i ++)
|
||||
for(j = 1; j <= M; j ++) del[i][j] = 1 - g[i][j];
|
||||
for(i = 0; i < K; i ++)
|
||||
for(j = 0; j < 9; j ++)
|
||||
{
|
||||
x = mon[i].x + ex[mon[i].d][j], y = mon[i].y + ey[mon[i].d][j];
|
||||
if(inside(x, y)) del[x][y] = 1;
|
||||
}
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
scanf("%d%d", &N, &M);
|
||||
for(i = 1; i <= N; i ++)
|
||||
{
|
||||
scanf("%s", b + 1);
|
||||
for(j = 1; j <= M; j ++)
|
||||
{
|
||||
g[i][j] = b[j] != '*';
|
||||
if(b[j]== 'A') sx = i, sy = j;
|
||||
else if(b[j] == 'B') tx = i, ty = j;
|
||||
}
|
||||
}
|
||||
scanf("%d", &K);
|
||||
for(i = 0; i < K; i ++) scanf("%d%d%d", &mon[i].x, &mon[i].y, &mon[i].d);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, x, y, cur, ans = -1;
|
||||
cur = -1;
|
||||
delblock();
|
||||
if(del[sx][sy])
|
||||
{
|
||||
printf("璐ュ靛朵涓 峰ユ澶т\n");
|
||||
return ;
|
||||
}
|
||||
std::queue <Point> q;
|
||||
q.push(Point(sx, sy, 0));
|
||||
while(!q.empty())
|
||||
{
|
||||
Point p = q.front();
|
||||
q.pop();
|
||||
if(p.t > 1000) break;
|
||||
if(p.x == tx && p.y == ty)
|
||||
{
|
||||
ans = p.t;
|
||||
break;
|
||||
}
|
||||
if(p.t > cur)
|
||||
{
|
||||
cur = p.t;
|
||||
for(i = 1; i <= N; i ++)
|
||||
for(j = 1; j <= M; j ++) vis[i][j] = 0;
|
||||
moveall(), delblock();
|
||||
}
|
||||
for(i = 0; i < 5; i ++)
|
||||
{
|
||||
x = p.x + dx[i], y = p.y + dy[i];
|
||||
if(inside(x, y) && !del[x][y] && !vis[x][y])
|
||||
vis[x][y] = 1, q.push(Point(x, y, p.t + 1));
|
||||
}
|
||||
}
|
||||
if(ans == -1) printf("璐ュ靛朵涓 峰ユ澶т\n");
|
||||
else printf("%d\n", ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, tt;
|
||||
scanf("%d", &t);
|
||||
for(tt = 1; tt <= t; tt ++)
|
||||
{
|
||||
init();
|
||||
printf("Case %d: ", tt);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int N=5006;
|
||||
stack <int> s;
|
||||
vector <int> adj[N], arc[N], com[N], ans;
|
||||
int n, m, t, ind, T, sum;
|
||||
int dfn[N], low[N], id[N], in[N];
|
||||
bool vs[N];
|
||||
void tarjan(int u)
|
||||
{
|
||||
dfn[u]=low[u]=T++;
|
||||
s.push(u), vs[u]=1;
|
||||
int len=(int)adj[u].size();
|
||||
for(int i=0; i<len; i++)
|
||||
{
|
||||
int v=adj[u][i];
|
||||
if(dfn[v]==-1)
|
||||
{
|
||||
tarjan(v);
|
||||
if(low[u]>low[v]) low[u]=low[v];
|
||||
}
|
||||
else if(vs[v] && low[u]>dfn[v]) low[u]=dfn[v];
|
||||
}
|
||||
if(low[u]==dfn[u])
|
||||
{
|
||||
for(int v; 1; )
|
||||
{
|
||||
v=s.top();
|
||||
s.pop(), vs[v]=0;
|
||||
id[v]=ind, com[ind].push_back(v);
|
||||
if(v==u) break;
|
||||
}
|
||||
ind++;
|
||||
}
|
||||
}
|
||||
void DFS(int u)
|
||||
{
|
||||
vs[u]=1;
|
||||
int len=(int)arc[u].size();
|
||||
sum+=(int)com[u].size();
|
||||
for(int i=0; i<len; i++)
|
||||
{
|
||||
int v=arc[u][i];
|
||||
if(vs[v]) continue;
|
||||
DFS(v);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &t);
|
||||
for(int ca=1; ca<=t; ca++)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i=0; i<n; i++) adj[i].clear();
|
||||
for(int i=0, a, b; i<m; i++)
|
||||
{
|
||||
scanf("%d%d", &a, &b);
|
||||
adj[a].push_back(b);
|
||||
}
|
||||
for(int i=0; i<n; i++) vs[i]=0, dfn[i]=-1, com[i].clear();
|
||||
ind=T=0;
|
||||
while(!s.empty()) s.pop();
|
||||
for(int i=0; i<n; i++) if(dfn[i]==-1) tarjan(i);
|
||||
for(int i=0; i<ind; i++) arc[i].clear(), in[i]=0, dfn[i]=0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
int len=(int)adj[i].size();
|
||||
for(int j=0; j<len; j++)
|
||||
{
|
||||
int v=id[adj[i][j]];
|
||||
int u=id[i];
|
||||
if(u!=v) arc[v].push_back(u), in[u]++;
|
||||
}
|
||||
}
|
||||
for(int i=0; i<ind; i++)
|
||||
{
|
||||
if(in[i]!=0) continue;
|
||||
for(int j=0; j<ind; j++) vs[j]=0;
|
||||
sum=0;
|
||||
DFS(i);
|
||||
dfn[i]=sum;
|
||||
}
|
||||
int Max=-0x3fffffff;
|
||||
for(int i=0; i<ind; i++)
|
||||
if(Max<dfn[i]) Max=dfn[i];
|
||||
ans.clear();
|
||||
for(int i=0; i<ind; i++)
|
||||
{
|
||||
if(dfn[i]!=Max) continue;
|
||||
int len=(int)com[i].size();
|
||||
for(int j=0; j<len; j++) ans.push_back(com[i][j]);
|
||||
}
|
||||
sort(ans.begin(), ans.end());
|
||||
int len=(int)ans.size();
|
||||
printf("Case %d: %d\n", ca, Max-1);
|
||||
for(int i=0; i<len; i++)
|
||||
{
|
||||
printf("%d", ans[i]);
|
||||
if(i==len-1) printf("\n");
|
||||
else printf(" ");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
const int MAX = 100 + 10;
|
||||
char Plant[MAX];
|
||||
int P, M;
|
||||
int Flag;
|
||||
int E;
|
||||
int MozNum;
|
||||
void init(char plant[])
|
||||
{
|
||||
MozNum = 0;
|
||||
E = strlen(plant) - 1;
|
||||
P = M = 0;
|
||||
for(int i = 0; i <= E; ++i)
|
||||
{
|
||||
if(plant[i] == 'P')
|
||||
++P;
|
||||
else
|
||||
++M;
|
||||
}
|
||||
}
|
||||
int run(int apNum, int ppNum, int mozNum)
|
||||
{
|
||||
int flag = Flag;
|
||||
int pLife = 10, mozLife = 50;
|
||||
while(ppNum > 0 && mozNum > 0)
|
||||
{
|
||||
if(flag > 0)
|
||||
{
|
||||
--flag;
|
||||
mozLife -= apNum;
|
||||
}
|
||||
else
|
||||
{
|
||||
pLife -= mozNum;
|
||||
mozLife -= apNum;
|
||||
}
|
||||
if(pLife <= 0)
|
||||
{
|
||||
pLife = 10;
|
||||
apNum--;
|
||||
ppNum--;
|
||||
flag = 1;
|
||||
}
|
||||
if(mozLife <= 0)
|
||||
{
|
||||
mozLife = 50;
|
||||
mozNum--;
|
||||
}
|
||||
}
|
||||
if(ppNum <= 0 && mozNum > 0)
|
||||
return 1;
|
||||
if(ppNum <= 0 && mozNum <= 0)
|
||||
return 0;
|
||||
if(ppNum > 0)
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for(int t = 1; t <= T; ++t)
|
||||
{
|
||||
scanf("%s", Plant);
|
||||
init(Plant);
|
||||
if(Plant[E] == 'M')
|
||||
{
|
||||
E--;
|
||||
MozNum++;
|
||||
Flag = 2;
|
||||
}
|
||||
else
|
||||
Flag = 1;
|
||||
while(E >= 0)
|
||||
{
|
||||
if(Plant[E] == 'M')
|
||||
{
|
||||
if(Flag > 1)
|
||||
{
|
||||
--Flag;
|
||||
if(P >= 50)
|
||||
++MozNum;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
MozNum++;
|
||||
M--;
|
||||
E--;
|
||||
Flag = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
int pNum = 0;
|
||||
for(int i = E; i >= 0; --i)
|
||||
{
|
||||
if(Plant[i] == 'M')
|
||||
break;
|
||||
else
|
||||
pNum++;
|
||||
}
|
||||
int left = 1, right = 2 * MAX, mid;
|
||||
while(left < right)
|
||||
{
|
||||
mid = (left + right) >> 1;
|
||||
if(run(P, pNum, mid) > 0)
|
||||
right = mid;
|
||||
else
|
||||
left = mid + 1;
|
||||
}
|
||||
MozNum += left;
|
||||
P -= pNum;
|
||||
E -= pNum + 1;
|
||||
Flag = 2;
|
||||
}
|
||||
}
|
||||
if(Plant[0] == 'M')
|
||||
++MozNum;
|
||||
printf("Case %d: %d\n", t, MozNum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#define MAXN 205
|
||||
#define INF 100000000
|
||||
#define eps 1e-9
|
||||
#define L(x) x<<1
|
||||
#define R(x) x<<1|1
|
||||
using namespace std;
|
||||
bool tag[101];
|
||||
__int64 p[101];
|
||||
int cnt = 0;
|
||||
void get_prime()
|
||||
{
|
||||
cnt = 0;
|
||||
for (__int64 i = 2; i < 101; i++)
|
||||
{
|
||||
if (!tag[i])
|
||||
p[cnt++] = i;
|
||||
for (__int64 j = 0; j < cnt && p[j] * i < 101; j++)
|
||||
{
|
||||
tag[i*p[j]] = 1;
|
||||
if (i % p[j] == 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
__int64 a[105];
|
||||
__int64 b[105];
|
||||
__int64 num[105];
|
||||
__int64 tmp[105];
|
||||
int main()
|
||||
{
|
||||
__int64 sum = 0;
|
||||
__int64 i, j;
|
||||
int t, n;
|
||||
scanf("%d", &t);
|
||||
get_prime();
|
||||
while(t--)
|
||||
{
|
||||
memset(num, 0, sizeof(num));
|
||||
__int64 high = 96000000099999999LL;
|
||||
__int64 low = 0LL;
|
||||
scanf("%d", &n);
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%I64d%I64d", &a[i], &b[i]);
|
||||
for(j = 0; j < cnt && p[j] * p[j] <= a[i]; j++)
|
||||
{
|
||||
__int64 ct = 0;
|
||||
if(a[i] % p[j] == 0)
|
||||
{
|
||||
while(a[i] % p[j] == 0)
|
||||
{
|
||||
ct++;
|
||||
a[i] /= p[j];
|
||||
}
|
||||
}
|
||||
num[p[j]] += ct * b[i];
|
||||
}
|
||||
if(a[i] > 1)
|
||||
{
|
||||
num[a[i]] += b[i];
|
||||
}
|
||||
}
|
||||
__int64 ans = 0;
|
||||
while(low <= high)
|
||||
{
|
||||
__int64 mid = (low + high) / 2;
|
||||
memset(tmp, 0, sizeof(tmp));
|
||||
for(i = 0; i < cnt && p[i] < 100; i++)
|
||||
{
|
||||
for(j = p[i]; j <= mid; j *= p[i])
|
||||
{
|
||||
tmp[p[i]] += mid / j;
|
||||
}
|
||||
}
|
||||
int big = 0;
|
||||
for(i = 0; p[i] < 100; i++)
|
||||
{
|
||||
if(num[p[i]] == 0) continue;
|
||||
if(num[p[i]] > tmp[p[i]])
|
||||
{
|
||||
big = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
int cn = 0;
|
||||
for(i = 0; p[i] < 100; i++)
|
||||
if(num[p[i]] > 0) cn++;
|
||||
int nc = 0;
|
||||
for(i = 0; p[i] < 100; i++)
|
||||
{
|
||||
if(num[p[i]] == 0) continue;
|
||||
if(tmp[p[i]] >= num[p[i]]) nc++;
|
||||
}
|
||||
if(nc == cn) big = 1;
|
||||
if(big == 0)
|
||||
break;
|
||||
else if(big == -1)
|
||||
{
|
||||
low = mid + 1;
|
||||
}
|
||||
else if(big == 1)
|
||||
{
|
||||
high = mid - 1;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n", low);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define lz 2*u,l,mid
|
||||
#define rz 2*u+1,mid+1,r
|
||||
const int maxn=2222;
|
||||
typedef long long lld;
|
||||
int flag[4*maxn];
|
||||
lld sum1[4*maxn], sum2[4*maxn], sum3[4*maxn];
|
||||
int X[maxn], Z[maxn];
|
||||
struct Node
|
||||
{
|
||||
int lx, rx, y, z1, z2, s;
|
||||
Node() {}
|
||||
Node(int lx_, int rx_ , int y_, int zm_, int zl_, int s_)
|
||||
{
|
||||
lx=lx_, rx=rx_, y=y_, z1=zm_, z2=zl_, s=s_;
|
||||
}
|
||||
bool operator<(const Node &S) const
|
||||
{
|
||||
if(y==S.y) return s>S.s;
|
||||
else return y<S.y;
|
||||
}
|
||||
} line[maxn], tmp[maxn];
|
||||
void push_up(int u, int l, int r)
|
||||
{
|
||||
if(flag[u]>=3)
|
||||
{
|
||||
sum3[u]=sum2[u]=sum1[u]=X[r+1]-X[l];
|
||||
}
|
||||
else if(flag[u]==2)
|
||||
{
|
||||
sum2[u]=sum1[u]=X[r+1]-X[l];
|
||||
if(l==r)sum3[u]=0;
|
||||
else
|
||||
sum3[u]=sum1[2*u]+sum1[2*u+1];
|
||||
}
|
||||
else if(flag[u]==1)
|
||||
{
|
||||
sum1[u]=X[r+1]-X[l];
|
||||
if(l==r)sum2[u]=sum3[u]=0;
|
||||
else
|
||||
{
|
||||
sum2[u]=sum1[2*u]+sum1[2*u+1];
|
||||
sum3[u]=sum2[2*u]+sum2[2*u+1];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(l==r)sum1[u]=sum2[u]=sum3[u]=0;
|
||||
else
|
||||
{
|
||||
sum1[u]=sum1[2*u]+sum1[2*u+1];
|
||||
sum2[u]=sum2[2*u]+sum2[2*u+1];
|
||||
sum3[u]=sum3[2*u]+sum3[2*u+1];
|
||||
}
|
||||
}
|
||||
}
|
||||
void Update(int u, int l, int r, int tl, int tr, int c)
|
||||
{
|
||||
if(tl>tr) return ;
|
||||
if(tl<=l&&r<=tr)
|
||||
{
|
||||
flag[u]+=c;
|
||||
push_up(u,l,r);
|
||||
return ;
|
||||
}
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) Update(lz,tl,tr,c);
|
||||
else if(tl>mid) Update(rz,tl,tr,c);
|
||||
else
|
||||
{
|
||||
Update(lz,tl,mid,c);
|
||||
Update(rz,mid+1,tr,c);
|
||||
}
|
||||
push_up(u,l,r);
|
||||
}
|
||||
int find(int tmp, int n)
|
||||
{
|
||||
int l=1, r=n, mid;
|
||||
while(l<=r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(X[mid]==tmp) return mid;
|
||||
else if(X[mid]<tmp) l=mid+1;
|
||||
else r=mid-1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, n, tcase=0;
|
||||
cin >> T;
|
||||
while(T--)
|
||||
{
|
||||
cin >> n ;
|
||||
int num=0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
int x1, y1, x2, y2, z1, z2;
|
||||
scanf("%d%d%d%d%d%d",&x1,&y1,&z1,&x2,&y2,&z2);
|
||||
line[++num]=Node(x1,x2,y1,z1,z2,1);
|
||||
X[num]=x1, Z[num]=z1;
|
||||
line[++num]=Node(x1,x2,y2,z1,z2,-1);
|
||||
X[num]=x2, Z[num]=z2;
|
||||
}
|
||||
sort(line+1,line+num+1);
|
||||
sort(X+1,X+num+1);
|
||||
sort(Z+1,Z+num+1);
|
||||
int ep=1, m=1;
|
||||
for(int i=2; i<=num; i++)
|
||||
if(X[i]!=X[ep]) X[++ep]=X[i];
|
||||
for(int i=2; i<=num; i++)
|
||||
if(Z[i]!=Z[m]) Z[++m]=Z[i];
|
||||
lld ans=0;
|
||||
for(int j=1; j<m; j++)
|
||||
{
|
||||
memset(flag,0,sizeof(flag));
|
||||
memset(sum1,0,sizeof(sum1));
|
||||
memset(sum2,0,sizeof(sum2));
|
||||
memset(sum3,0,sizeof(sum3));
|
||||
lld tp=0, cnt=0;
|
||||
for(int i=1; i<=num; i++)
|
||||
{
|
||||
if(line[i].z1<=Z[j]&&Z[j]<line[i].z2)
|
||||
tmp[++cnt]=line[i];
|
||||
}
|
||||
for(int i=1; i<cnt; i++)
|
||||
{
|
||||
int l=find(tmp[i].lx,ep);
|
||||
int r=find(tmp[i].rx,ep)-1;
|
||||
Update(1,1,ep-1,l,r,tmp[i].s);
|
||||
tp+=(lld)sum3[1]*(lld)(tmp[i+1].y-tmp[i].y);
|
||||
}
|
||||
ans+=(lld)tp*(lld)(Z[j+1]-Z[j]);
|
||||
}
|
||||
printf("Case %d: %I64d\n",++tcase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 100;
|
||||
const double eps = 1e-3;
|
||||
const int times = 5;
|
||||
const double INF = 99999999;
|
||||
int n;
|
||||
struct point
|
||||
{
|
||||
double x, y, r;
|
||||
} p[maxn], test[maxn];
|
||||
inline int dblcmp( double x )
|
||||
{
|
||||
if( fabs(x) < eps )
|
||||
return 0;
|
||||
return x > 0 ? 1 : -1;
|
||||
}
|
||||
inline double sqr( double x )
|
||||
{
|
||||
return x*x;
|
||||
}
|
||||
double dis( point& aa, point& bb )
|
||||
{
|
||||
return sqrt(sqr(aa.x-bb.x)+sqr(aa.y-bb.y));
|
||||
}
|
||||
double cross( point& k, point& aa, point& bb )
|
||||
{
|
||||
return (k.x-aa.x)*(k.y-bb.y)-(k.y-aa.y)*(k.x-bb.x);
|
||||
}
|
||||
double seg_point_dis( point& l1, point& l2, point& k )
|
||||
{
|
||||
double a, b, c;
|
||||
a = dis(l1, k);
|
||||
b = dis(l2, k);
|
||||
c = dis(l1, l2);
|
||||
if( dblcmp(a*a+c*c-b*b) < 0 )
|
||||
return a;
|
||||
else if( dblcmp(b*b+c*c-a*a) < 0 )
|
||||
return b;
|
||||
else
|
||||
return fabs(cross(k, l1, l2)/c);
|
||||
}
|
||||
bool point_inside( point& aa )
|
||||
{
|
||||
int i, cnt = 0;
|
||||
double t;
|
||||
for( i = 0; i < n; ++i )
|
||||
{
|
||||
if( (p[i].y <= aa.y && p[i+1].y > aa.y) ||
|
||||
(p[i+1].y <= aa.y && p[i].y > aa.y) )
|
||||
{
|
||||
if( !dblcmp(p[i].y-p[i+1].y) )
|
||||
{
|
||||
if( dblcmp(p[i].y-aa.y) == 0 )
|
||||
cnt++;
|
||||
t = -INF;
|
||||
}
|
||||
else
|
||||
t = p[i+1].x - (p[i+1].x-p[i].x)*(p[i+1].y-aa.y)/(p[i+1].y-p[i].y);
|
||||
if( dblcmp( t - aa.x ) >= 0 )
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
return cnt%2;
|
||||
}
|
||||
void cal( point& aa )
|
||||
{
|
||||
double t;
|
||||
aa.r = INF;
|
||||
for( int i = 0; i < n; ++i )
|
||||
{
|
||||
t = seg_point_dis(p[i], p[i+1], aa);
|
||||
aa.r = min(aa.r, t);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j;
|
||||
double R, delte, maxx, maxy, minx, miny, ang;
|
||||
point temp;
|
||||
bool ok;
|
||||
while( scanf("%d", &n), n )
|
||||
{
|
||||
ok = 0;
|
||||
maxx = maxy = 0;
|
||||
minx = miny = INF;
|
||||
for( i = 0; i < n; ++i )
|
||||
{
|
||||
scanf("%lf %lf", &p[i].x, &p[i].y);
|
||||
maxx = max(maxx, p[i].x);
|
||||
maxy = max(maxy, p[i].y);
|
||||
minx = min(minx, p[i].x);
|
||||
miny = min(miny, p[i].y);
|
||||
}
|
||||
p[n] = p[0];
|
||||
for( i = 0; i < n; ++i )
|
||||
{
|
||||
test[i].x = (p[i].x+p[i+1].x)/2;
|
||||
test[i].y = (p[i].y+p[i+1].y)/2;
|
||||
test[i].r = 0;
|
||||
}
|
||||
scanf("%lf", &R);
|
||||
maxx -= minx; maxy -= miny;
|
||||
delte = sqrt(maxx*maxx+maxy*maxy)/2;
|
||||
while( !ok && delte > eps )
|
||||
{
|
||||
for( i = 0; !ok && i < n; ++i )
|
||||
{
|
||||
for( j = 0; !ok && j < times; ++j )
|
||||
{
|
||||
ang = rand();
|
||||
temp.x = test[i].x + delte*cos(ang);
|
||||
temp.y = test[i].y + delte*sin(ang);
|
||||
if( point_inside(temp) )
|
||||
{
|
||||
cal(temp);
|
||||
if( temp.r > test[i].r )
|
||||
{
|
||||
test[i] = temp;
|
||||
if( dblcmp(temp.r-R) >= 0 )
|
||||
ok = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
delte *= 0.90;
|
||||
}
|
||||
if( ok )
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
typedef vector<int> vi;
|
||||
map<string, int> pos;
|
||||
map<int, int> line;
|
||||
const char *resetTime = "[0000/00/00 00:00:00]";
|
||||
int ttEvent, ttLine;
|
||||
struct Line{
|
||||
char timeMark[30];
|
||||
int line;
|
||||
int id;
|
||||
}lineInform[50001];
|
||||
struct Author{
|
||||
char name[35];
|
||||
int pri;
|
||||
char syncTime[30];
|
||||
vi modify;
|
||||
}author[10001];
|
||||
struct Event{
|
||||
char timeMark[30];
|
||||
int op;
|
||||
int id;
|
||||
}event[50001];
|
||||
bool cmpEvent(const Event a, const Event b){
|
||||
return strcmp(a.timeMark, b.timeMark) < 0;
|
||||
}
|
||||
bool cmpLine(const Line a, const Line b){
|
||||
return a.line < b.line;
|
||||
}
|
||||
void pre(int n){
|
||||
int k;
|
||||
char tm1[30], tm2[15], op[10];
|
||||
ttEvent = ttLine = 0;
|
||||
pos.clear();
|
||||
line.clear();
|
||||
for (int i = 0; i < n; i++){
|
||||
scanf("%s%d%d", author[i].name, &author[i].pri, &k);
|
||||
pos[author[i].name] = i;
|
||||
author[i].modify.clear();
|
||||
while (k--){
|
||||
scanf("%s%s%s", tm1, tm2, op);
|
||||
strcat(tm1, " ");
|
||||
strcat(tm1, tm2);
|
||||
strcpy(event[ttEvent].timeMark, tm1);
|
||||
if (!strcmp(op, "SYNC")){
|
||||
event[ttEvent].op = -1;
|
||||
}
|
||||
else if (!strcmp(op, "SUBMIT")){
|
||||
event[ttEvent].op = -2;
|
||||
}
|
||||
else{
|
||||
assert(!strcmp(op, "MODIFY"));
|
||||
scanf("%d", &event[ttEvent].op);
|
||||
if (!line.count(event[ttEvent].op)){
|
||||
line[event[ttEvent].op] = ttLine;
|
||||
strcpy(lineInform[ttLine].timeMark, resetTime);
|
||||
lineInform[ttLine++].line = event[ttEvent].op;
|
||||
}
|
||||
}
|
||||
event[ttEvent++].id = i;
|
||||
}
|
||||
}
|
||||
sort(event, event + ttEvent, cmpEvent);
|
||||
}
|
||||
void run(){
|
||||
for (int i = 0; i < ttEvent; i++){
|
||||
switch (event[i].op){
|
||||
case -2:
|
||||
{
|
||||
int id = event[i].id;
|
||||
int pri = author[id].pri;
|
||||
for (vi::iterator ii = author[id].modify.begin(); ii != author[id].modify.end(); ii++){
|
||||
int linePos = line[*ii];
|
||||
int lineID = lineInform[linePos].id;
|
||||
//printf("cmp %s %s\n", lineInform[linePos].timeMark, author[id].syncTime);
|
||||
if (strcmp(lineInform[linePos].timeMark, author[id].syncTime) < 0){
|
||||
strcpy(lineInform[linePos].timeMark, event[i].timeMark);
|
||||
lineInform[linePos].id = id;
|
||||
}
|
||||
else if (author[lineID].pri < pri){
|
||||
strcpy(lineInform[linePos].timeMark, event[i].timeMark);
|
||||
lineInform[linePos].id = id;
|
||||
}
|
||||
}
|
||||
strcpy(author[id].syncTime, event[i].timeMark);
|
||||
author[id].modify.clear();
|
||||
}
|
||||
break;
|
||||
case -1:
|
||||
{
|
||||
strcpy(author[event[i].id].syncTime, event[i].timeMark);
|
||||
author[event[i].id].modify.clear();
|
||||
}break;
|
||||
default:
|
||||
{
|
||||
author[event[i].id].modify.push_back(event[i].op);
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(lineInform, lineInform + ttLine, cmpLine);
|
||||
}
|
||||
void print(){
|
||||
for (int i = 0; i < ttLine; i++){
|
||||
if (strcmp(lineInform[i].timeMark, resetTime)) printf("%d %s BY %s\n", lineInform[i].line, lineInform[i].timeMark, author[lineInform[i].id].name);
|
||||
}
|
||||
puts("END");
|
||||
}
|
||||
int main(){
|
||||
int n;
|
||||
while (~scanf("%d", &n) && n){
|
||||
pre(n);
|
||||
run();
|
||||
print();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include <iostream>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define INF 0x7ffffffffffLL
|
||||
#define N 10010
|
||||
#define M 100010
|
||||
#define LL long long
|
||||
#define mod 95041567
|
||||
using namespace std;
|
||||
struct node{
|
||||
int index;
|
||||
int val;
|
||||
};
|
||||
int n, m, k, MAX;
|
||||
int fb[N], life[M];
|
||||
node dp[N][110];
|
||||
node cal(int x, int y, bool f){
|
||||
node v = dp[x - 1][y];
|
||||
int z = fb[x];
|
||||
if(f) v = dp[x - 1][y - 1], z *= 2;
|
||||
bool flag = 0;
|
||||
while(v.index <= k){
|
||||
if(v.val > z){
|
||||
if(!flag) v.val -= z;
|
||||
return v;
|
||||
}
|
||||
else{
|
||||
if(v.index) flag = 1;
|
||||
z -= v.val;
|
||||
v.val = life[++v.index];
|
||||
if(v.index > 1 && z == 0) return v;
|
||||
}
|
||||
}
|
||||
return v;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d %d %d", &n, &m, &k) != EOF){
|
||||
if(n + m + k ==0) break;
|
||||
for(int i = 1; i <= n; ++i)
|
||||
scanf("%d", &fb[i]);
|
||||
for(int i = 1; i <= k; ++i)
|
||||
scanf("%d", &life[i]);
|
||||
if(!k){
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
MAX = 0;
|
||||
dp[0][0].index = 0, dp[0][0].val = 0;
|
||||
for(int i = 1; i <= n; ++i){
|
||||
int p = min(i, m);
|
||||
for(int j = 0; j <= p; ++j){
|
||||
node x = cal(i, j, 0);
|
||||
if(!j){
|
||||
dp[i][j] = x;
|
||||
MAX = max(MAX, dp[i][j].index - 1);
|
||||
continue;
|
||||
}
|
||||
node y = cal(i, j, 1);
|
||||
if(j == i){
|
||||
dp[i][j] = y;
|
||||
MAX = max(MAX, dp[i][j].index - 1);
|
||||
continue;
|
||||
}
|
||||
if(x.index > y.index) dp[i][j] = x;
|
||||
else if(x.index < y.index) dp[i][j] = y;
|
||||
else if(x.val > y.val) dp[i][j] = y;
|
||||
else dp[i][j] = x;
|
||||
MAX = max(MAX, dp[i][j].index - 1);
|
||||
}
|
||||
if(p <= m) dp[i][p + 1] = dp[i][p];
|
||||
}
|
||||
printf("%d\n", MAX);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int rr, c[1111111];
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x & (-x);
|
||||
}
|
||||
void add(int i, int val)
|
||||
{
|
||||
while(i <= rr){
|
||||
c[i] += val;
|
||||
i += lowbit(i);
|
||||
}
|
||||
}
|
||||
int sum(int i)
|
||||
{
|
||||
int s = 0;
|
||||
while(i > 0){
|
||||
s += c[i];
|
||||
i -= lowbit(i);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int mat[555][555];
|
||||
int ans[555][555];
|
||||
int mm;
|
||||
int Bin()
|
||||
{
|
||||
int l = 1, r = rr;
|
||||
while(l < r){
|
||||
int m = (l + r) >> 1;
|
||||
if(sum(m) >= mm) r = m;
|
||||
else l = m + 1;
|
||||
}
|
||||
return l - 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, r;
|
||||
while(scanf("%d %d", &n, &r) == 2){
|
||||
if(!n && !r) {
|
||||
break;
|
||||
}
|
||||
r = (r << 1) + 1;
|
||||
mm = (r * r + 1) >> 1;
|
||||
rr = -1;
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++){
|
||||
scanf("%d", &mat[i][j]);
|
||||
rr = max(rr, mat[i][j] + 1);
|
||||
}
|
||||
memset(c, 0, sizeof(c));
|
||||
for(int i = 0; i < r; i++){
|
||||
for(int j = 0; j < r - 1; j++){
|
||||
add(mat[i][j] + 1, 1);
|
||||
}
|
||||
}
|
||||
for(int i = 0; ; ){
|
||||
for(int j = r - 1; j < n; j++){
|
||||
for(int k = 0; k < r; k++)
|
||||
add(mat[i + k][j] + 1, 1);
|
||||
ans[i][j - (r - 1)] = Bin();
|
||||
for(int k = 0; k < r; k++)
|
||||
add(mat[i + k][j - (r - 1)] + 1, -1);
|
||||
}
|
||||
for(int j = n - 1; j >= n - (r - 1); j--)
|
||||
add(mat[i][j] + 1, -1);
|
||||
i++;
|
||||
if(i + (r - 1) >= n) break;
|
||||
for(int j = n - 1; j >= n - (r - 1); j--)
|
||||
add(mat[i + (r - 1)][j] + 1, 1);
|
||||
for(int j = n - r; j >= 0; j--){
|
||||
for(int k = 0; k < r; k++)
|
||||
add(mat[i + k][j] + 1, 1);
|
||||
ans[i][j] = Bin();
|
||||
for(int k = 0; k < r; k++)
|
||||
add(mat[i + k][j + (r - 1)] + 1, -1);
|
||||
}
|
||||
for(int j = 0; j < (r - 1); j++)
|
||||
add(mat[i][j] + 1, -1);
|
||||
i++;
|
||||
if(i + (r - 1) >= n) break;
|
||||
for(int j = 0; j < (r - 1); j++)
|
||||
add(mat[i + (r - 1)][j] + 1, 1);
|
||||
}
|
||||
for(int i = 0; i <= n - r; i++){
|
||||
for(int j = 0; j <= n - r; j++){
|
||||
printf("%d ", ans[i][j]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
int red[10],black[10],first;
|
||||
int solve(){
|
||||
if(black[1]-red[1]==1) return first;
|
||||
if(red[4]-1>10-black[4]) return 0;
|
||||
if(red[4]-1<10-black[4]) return 1;
|
||||
int sg=0;
|
||||
sg^=(black[2]-red[2]-1);
|
||||
sg^=(black[3]-red[3]-1);
|
||||
sg^=(black[1]-red[1])%2;
|
||||
if(sg) return first;
|
||||
else return first^1;
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%d",&first)!=EOF){
|
||||
for(int i=1;i<=4;i++) scanf("%d",&red[i]);
|
||||
for(int i=1;i<=4;i++) scanf("%d",&black[i]);
|
||||
if ( !solve() ) printf("Red\n");
|
||||
else printf("Black\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#define N 86444
|
||||
using namespace std;
|
||||
int s[N],e[N],n;
|
||||
inline void read()
|
||||
{
|
||||
memset(s,0,sizeof s);
|
||||
memset(e,0,sizeof e);
|
||||
for(int i=1,a,b;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(a>b) swap(a,b);
|
||||
s[a]++; e[b]++;
|
||||
}
|
||||
}
|
||||
inline void go()
|
||||
{
|
||||
int ans=0,res=0;
|
||||
for(int i=0;i<=86400;i++)
|
||||
{
|
||||
res+=s[i];
|
||||
ans=max(ans,res);
|
||||
res-=e[i];
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n),n) read(),go();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int inf=1e9;
|
||||
string st;
|
||||
int dp[110][15][15];
|
||||
int DP(int len,int x,int y){
|
||||
if(len==0) return 0;
|
||||
if(dp[len][x][y]!=-1) return dp[len][x][y];
|
||||
int ans=inf,pos=st[st.length()-len]-'0';
|
||||
if(pos==0) pos=10;
|
||||
for(int i=0;i<pos;i++){
|
||||
int tmp=DP(len-1,i,pos)+max(abs(i-x),abs(y-pos)+1 );
|
||||
if(tmp<ans) ans=tmp;
|
||||
}
|
||||
for(int i=pos+1;i<=10;i++){
|
||||
int tmp=DP(len-1,pos,i)+ max(abs(i-y),abs(x-pos)+1 );
|
||||
if(tmp<ans) ans=tmp;
|
||||
}
|
||||
return dp[len][x][y]=ans;
|
||||
}
|
||||
int main(){
|
||||
while(cin>>st){
|
||||
memset(dp,-1,sizeof(dp));
|
||||
cout<<DP(st.length(),5,6)<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int bit[15];
|
||||
int dp[15][15][3];
|
||||
int dfs(int pos,int mod,int have,int lim)
|
||||
{
|
||||
int num,i,ans,mod_x,have_x;
|
||||
if(pos<=0)
|
||||
return mod == 0 && have == 2;
|
||||
if(!lim && dp[pos][mod][have] != -1)
|
||||
return dp[pos][mod][have];
|
||||
num = lim?bit[pos]:9;
|
||||
ans = 0;
|
||||
for(i = 0; i<=num; i++)
|
||||
{
|
||||
mod_x = (mod*10+i)%13;
|
||||
have_x = have;
|
||||
if(have == 0 && i == 1)
|
||||
have_x = 1;
|
||||
if(have == 1 && i != 1)
|
||||
have_x = 0;
|
||||
if(have == 1 && i == 3)
|
||||
have_x = 2;
|
||||
ans+=dfs(pos-1,mod_x,have_x,lim&&i==num);
|
||||
}
|
||||
if(!lim)
|
||||
dp[pos][mod][have] = ans;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,len;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
memset(bit,0,sizeof(bit));
|
||||
memset(dp,-1,sizeof(dp));
|
||||
len = 0;
|
||||
while(n)
|
||||
{
|
||||
bit[++len] = n%10;
|
||||
n/=10;
|
||||
}
|
||||
printf("%d\n",dfs(len,0,0,1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#define LL __int64
|
||||
const int N = 1e9;
|
||||
using namespace std;
|
||||
int r, d[10005], n[40], pr[10005], qpr[10005], tq;
|
||||
void Pr()
|
||||
{
|
||||
int i, j;
|
||||
memset( pr, 1, sizeof(pr) );
|
||||
pr[1] = 0;
|
||||
for( i = 2; i <= 10000; i ++ )
|
||||
if( pr[i] )
|
||||
{
|
||||
j = i+i;
|
||||
while( j <= 10000 )
|
||||
{
|
||||
pr[j] = 0;
|
||||
j += i;
|
||||
}
|
||||
qpr[tq++] = i;
|
||||
}
|
||||
}
|
||||
int Gcd( int a, int b )
|
||||
{
|
||||
if( !b )
|
||||
return a;
|
||||
else
|
||||
return Gcd( b, a%b );
|
||||
}
|
||||
void Op()
|
||||
{
|
||||
memset( d, 0, sizeof(d) );
|
||||
int t, i, j, tt;
|
||||
for( j = 0; j < r; j ++ )
|
||||
{
|
||||
t = n[j];
|
||||
for( i = 0; i < tq && t > 1; i ++ )
|
||||
if( !( t % qpr[i] ) )
|
||||
{
|
||||
tt = 1;
|
||||
t/=qpr[i];
|
||||
while( !( t%qpr[i] ) )
|
||||
{
|
||||
tt ++;
|
||||
t/=qpr[i];
|
||||
}
|
||||
d[ qpr[i] ] = d[ qpr[i] ] > tt ? d[ qpr[i] ] : tt;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j, k, ti, qu[10004], top, na, mu[30];
|
||||
LL qa[30], t, ans;
|
||||
Pr();
|
||||
while( ~scanf( "%d", &r ) )
|
||||
{
|
||||
for( i = 0; i < r; i ++ )
|
||||
{
|
||||
scanf( "%d%d", n+i, &k );
|
||||
k = Gcd( n[i], k );
|
||||
n[i] /= k;
|
||||
}
|
||||
Op();
|
||||
ans = 1;
|
||||
top = 0;
|
||||
for( i = 0; i < tq; i ++ )
|
||||
if( d[ qpr[i] ] > 0)
|
||||
{
|
||||
ans *= d[ qpr[i] ]+1;
|
||||
qu[ top++ ] = qpr[i];
|
||||
}
|
||||
if( top > 0 && qu[0] == 2 )
|
||||
na = 2;
|
||||
else
|
||||
na = 1;
|
||||
printf( "%I64d\n", ans-na );
|
||||
ans = ans < 16+na ? ans : 16+na;
|
||||
qa[0] = 1;
|
||||
mu[0] = 0;
|
||||
for( k = 1; k < ans; k ++ )
|
||||
{
|
||||
t = N*(LL)N;
|
||||
for( i = 0; i < k; i ++ )
|
||||
if( mu[i] < top && qu[ mu[i] ] * qa[i] < t )
|
||||
t = qu[ mu[i] ]*qa[i];
|
||||
qa[k] = t;
|
||||
mu[k] = -1;
|
||||
for( j = 0; j <= k; j ++ )
|
||||
if( mu[j] < 0 || ( mu[j] < top && qu[ mu[j] ] * qa[j] == qa[k] ) )
|
||||
{
|
||||
for( i = mu[j]+1; i < top; i ++ )
|
||||
{
|
||||
ti = 0;
|
||||
t = qa[j];
|
||||
while( !( t % qu[i] ) )
|
||||
{
|
||||
ti ++;
|
||||
t /= qu[i];
|
||||
}
|
||||
if( ti < d[ qu[i] ] )
|
||||
break;
|
||||
}
|
||||
mu[j] = i;
|
||||
}
|
||||
}
|
||||
if( na < ans )
|
||||
{
|
||||
printf( "%I64d", qa[na] );
|
||||
na ++;
|
||||
for( j = 1; na < ans && j < 16; na ++, j ++ )
|
||||
printf( " %I64d", qa[na] );
|
||||
printf( "\n" );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#define N 3010
|
||||
#define M 200010
|
||||
#define inf 200000000
|
||||
typedef long long ll;
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int head[N],cnt;
|
||||
int dp[4][N];
|
||||
bool vis[N];
|
||||
vector<int>vv;
|
||||
struct Edge{
|
||||
int v,c,ne;
|
||||
}edge[M*2];
|
||||
void addedge(int u,int v,int w){
|
||||
edge[cnt].v=v;
|
||||
edge[cnt].c=w;
|
||||
edge[cnt].ne=head[u];
|
||||
head[u]=cnt++;
|
||||
edge[cnt].v=u;
|
||||
edge[cnt].c=w;
|
||||
edge[cnt].ne=head[v];
|
||||
head[v]=cnt++;
|
||||
}
|
||||
void init(){
|
||||
memset(head,-1,sizeof(head));
|
||||
cnt=0;
|
||||
}
|
||||
void SPFA(int u){
|
||||
queue<int>q;
|
||||
int i;
|
||||
for(i=1;i<=n;i++){
|
||||
dp[u][i]=inf;
|
||||
vis[i]=0;
|
||||
}
|
||||
q.push(u);
|
||||
dp[u][u]=0;
|
||||
vis[u]=1;
|
||||
while(!q.empty()){
|
||||
int v=q.front();
|
||||
q.pop();
|
||||
for(int i=head[v];i!=-1;i=edge[i].ne){
|
||||
int vv=edge[i].v;
|
||||
if(dp[u][v]+edge[i].c<dp[u][vv]){
|
||||
dp[u][vv]=dp[u][v]+edge[i].c;
|
||||
if(!vis[vv]){
|
||||
vis[vv]=1;
|
||||
q.push(vv);
|
||||
}
|
||||
}
|
||||
}
|
||||
vis[v]=0;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int i,j,u,v,w;
|
||||
while(scanf("%d %d",&n,&m)==2){
|
||||
init();
|
||||
for(i=1;i<=m;i++){
|
||||
scanf("%d %d %d",&u,&v,&w);
|
||||
addedge(u,v,w);
|
||||
}
|
||||
for(i=1;i<=3;i++)
|
||||
SPFA(i);
|
||||
vv.clear();
|
||||
for(i=1;i<=n;i++){
|
||||
int flag=1;
|
||||
for(j=head[i];j!=-1;j=edge[j].ne){
|
||||
int num=0;
|
||||
if(dp[1][edge[j].v]+edge[j].c==dp[1][i])num++;
|
||||
if(dp[2][edge[j].v]+edge[j].c==dp[2][i])num++;
|
||||
if(dp[3][edge[j].v]+edge[j].c==dp[3][i])num++;
|
||||
if(num>1){
|
||||
flag=0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag && dp[1][i]!=inf && dp[2][i]!=inf && dp[3][i]!=inf)
|
||||
vv.push_back(i);
|
||||
}
|
||||
int len=vv.size();
|
||||
if(len){
|
||||
printf("%d\n",len);
|
||||
for(i=0;i<len;i++){
|
||||
if(!i)
|
||||
printf("%d",vv[i]);
|
||||
else
|
||||
printf(" %d",vv[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
else
|
||||
printf("impossible\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int oo=0x3f3f3f3f;
|
||||
const int MAX=120;
|
||||
const int head=0;
|
||||
int up[MAX*MAX],down[MAX*MAX],left[MAX*MAX],right[MAX*MAX];
|
||||
int cnt[MAX],h[MAX],col[MAX*MAX];
|
||||
int K,ans;
|
||||
int nc;
|
||||
void remove(const int& c){
|
||||
for(int i=down[c];i!=c;i=down[i]){
|
||||
left[right[i]]=left[i];
|
||||
right[left[i]]=right[i];
|
||||
cnt[col[i]]--;
|
||||
}
|
||||
}
|
||||
void resume(const int& c){
|
||||
for(int i=up[c];i!=c;i=up[i]){
|
||||
left[right[i]]=i;
|
||||
right[left[i]]=i;
|
||||
cnt[col[i]]++;
|
||||
}
|
||||
}
|
||||
int evalute(){
|
||||
bool vis[MAX]={0};
|
||||
int ret=0;
|
||||
for(int i=right[head];i!=head;i=right[i]){
|
||||
if(!vis[i]){
|
||||
ret++;
|
||||
vis[i]=true;
|
||||
for(int j=down[i];j!=i;j=down[j]){
|
||||
for(int k=right[j];k!=j;k=right[k]){
|
||||
vis[col[k]]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool dfs(const int& k){
|
||||
if(k+evalute()>ans){
|
||||
return false;
|
||||
}
|
||||
if(right[head]==head){
|
||||
return true;
|
||||
}
|
||||
int s=oo,c=0;
|
||||
for(int i=right[head];i!=head;i=right[i]){
|
||||
if(cnt[i]<s){
|
||||
s=cnt[i];
|
||||
c=i;
|
||||
if(cnt[i]<=1){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=down[c];i!=c;i=down[i]){
|
||||
remove(i);
|
||||
for(int j=right[i];j!=i;j=right[j]){
|
||||
remove(j);
|
||||
}
|
||||
if(dfs(k+1)){
|
||||
return true;
|
||||
}
|
||||
for(int j=left[i];j!=i;j=left[j]){
|
||||
resume(j);
|
||||
}
|
||||
resume(i);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void init(){
|
||||
for(int i=0;i<=nc;i++){
|
||||
h[i]=-1;
|
||||
left[i]=i-1;
|
||||
right[i]=i+1;
|
||||
up[i]=down[i]=i;
|
||||
cnt[i]=0;
|
||||
col[i]=i;
|
||||
}
|
||||
left[head]=nc;
|
||||
right[nc]=head;
|
||||
K=nc;
|
||||
for(int i=1;i<=nc;i++){
|
||||
h[i]=-1;
|
||||
}
|
||||
}
|
||||
void add(const int& r,const int& c){
|
||||
K++;
|
||||
col[K]=c;
|
||||
up[K]=c;
|
||||
down[K]=down[c];
|
||||
if(h[r]==-1){
|
||||
h[r]=right[K]=K;
|
||||
}
|
||||
left[K]=h[r];
|
||||
right[K]=right[h[r]];
|
||||
left[right[K]]=K;
|
||||
right[left[K]]=K;
|
||||
up[down[K]]=K;
|
||||
down[up[K]]=K;
|
||||
}
|
||||
struct Node{
|
||||
int x,y;
|
||||
}city[MAX];
|
||||
int dis[MAX][MAX];
|
||||
int que[MAX*MAX],top;
|
||||
int sqr(int x){
|
||||
return x*x;
|
||||
}
|
||||
int operator*(const Node& a,const Node& b){
|
||||
return sqr(a.x-b.x)+sqr(a.y-b.y);
|
||||
}
|
||||
void build(const int& mid){
|
||||
init();
|
||||
for(int i=1;i<=nc;i++){
|
||||
for(int j=1;j<=nc;j++){
|
||||
if(dis[i][j]<=mid){
|
||||
add(i,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void run(){
|
||||
int l=0,r=top;
|
||||
int mid,ans;
|
||||
while(l<=r){
|
||||
mid=(l+r)/2;
|
||||
build(que[mid]);
|
||||
if(dfs(0)){
|
||||
ans=que[mid];
|
||||
r=mid-1;
|
||||
}else{
|
||||
l=mid+1;
|
||||
}
|
||||
}
|
||||
printf("%.6f\n",sqrt((double)ans));
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d%d",&nc,&ans);
|
||||
for(int i=1;i<=nc;i++){
|
||||
scanf("%d%d",&city[i].x,&city[i].y);
|
||||
}
|
||||
top=0;
|
||||
for(int i=1;i<=nc;i++){
|
||||
for(int j=1;j<=nc;j++){
|
||||
que[top++]=dis[i][j]=city[i]*city[j];
|
||||
}
|
||||
}
|
||||
int tmp=top;
|
||||
sort(que,que+top);
|
||||
top=1;
|
||||
for(int i=1;i<tmp;i++){
|
||||
if(que[i]!=que[i-1]){
|
||||
que[top++]=que[i];
|
||||
}
|
||||
}
|
||||
run();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#define MAXN 55
|
||||
#define MAXM 55*55
|
||||
#define inf 1<<30
|
||||
using namespace std;
|
||||
struct Edge{
|
||||
int v,cap,next;
|
||||
}edge[MAXM*11];
|
||||
int map[MAXN][MAXN];
|
||||
int head[MAXM];
|
||||
int pre[MAXM];
|
||||
int cur[MAXM];
|
||||
int level[MAXM];
|
||||
int gap[MAXM];
|
||||
int vs,vt,NV,n,m,k,NE;
|
||||
bool mark[MAXN][MAXN];
|
||||
int dir[4][2]={{-1,0},{1,0},{0,1},{0,-1}};
|
||||
void Insert(int u,int v,int cap,int cc=0){
|
||||
edge[NE].cap=cap;edge[NE].v=v;
|
||||
edge[NE].next=head[u];head[u]=NE++;
|
||||
edge[NE].cap=cc;edge[NE].v=u;
|
||||
edge[NE].next=head[v];head[v]=NE++;
|
||||
}
|
||||
int SAP(int vs,int vt){
|
||||
memset(level,0,sizeof(level));
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(gap,0,sizeof(gap));
|
||||
for(int i=0;i<=NV;i++)cur[i]=head[i];
|
||||
int u=pre[vs]=vs;
|
||||
int maxflow=0,aug=-1;
|
||||
gap[0]=NV;
|
||||
while(level[vs]<NV){
|
||||
loop :
|
||||
for(int &i=cur[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&level[u]==level[v]+1){
|
||||
aug==-1?(aug=edge[i].cap):(aug=min(aug,edge[i].cap));
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==vt){
|
||||
maxflow+=aug;
|
||||
for(u=pre[v];v!=vs;v=u,u=pre[u]){
|
||||
edge[cur[u]].cap-=aug;
|
||||
edge[cur[u]^1].cap+=aug;
|
||||
}
|
||||
aug=-1;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
int minlevel=NV;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&minlevel>level[v]){
|
||||
cur[u]=i;
|
||||
minlevel=level[v];
|
||||
}
|
||||
}
|
||||
if((--gap[level[u]])==0)break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
int main(){
|
||||
int u,v,sum;
|
||||
while(~scanf("%d%d%d",&n,&m,&k)){
|
||||
vs=0,vt=n*m+1,NV=vt+1,sum=0,NE=0;
|
||||
memset(mark,false,sizeof(mark));
|
||||
memset(head,-1,sizeof(head));
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=1;j<=m;j++){
|
||||
scanf("%d",&map[i][j]);
|
||||
sum+=map[i][j];
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=k;i++){
|
||||
scanf("%d%d",&u,&v);
|
||||
mark[u][v]=true;
|
||||
}
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=1;j<=m;j++){
|
||||
if((i+j)%2==1){
|
||||
mark[i][j]?Insert(vs,(i-1)*m+j,inf):Insert(vs,(i-1)*m+j,map[i][j]);
|
||||
for(int l=0;l<4;l++){
|
||||
int xx=i+dir[l][0],yy=j+dir[l][1];
|
||||
if(xx>=1&&xx<=n&&yy>=1&&yy<=m){
|
||||
Insert((i-1)*m+j,(xx-1)*m+yy,(map[i][j]&map[xx][yy])*2);
|
||||
}
|
||||
}
|
||||
}else{
|
||||
mark[i][j]?Insert((i-1)*m+j,vt,inf):Insert((i-1)*m+j,vt,map[i][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",sum-SAP(vs,vt));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
#define LL __int64
|
||||
const int mod=1000000007;
|
||||
struct matrix{
|
||||
LL f[52][52];
|
||||
};
|
||||
matrix mul(matrix a,matrix b)
|
||||
{
|
||||
int i,j,k;
|
||||
matrix c;
|
||||
memset(c.f,0,sizeof(c.f));
|
||||
for(i=0;i<52;i++)
|
||||
{
|
||||
for(j=0;j<52;j++)
|
||||
{
|
||||
for(k=0;k<52;k++)
|
||||
{
|
||||
c.f[i][j]+=a.f[i][k]*b.f[k][j]%mod;
|
||||
}
|
||||
c.f[i][j]%=mod;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
matrix pow_mod(matrix a,int b)
|
||||
{
|
||||
matrix s;
|
||||
int i,j;
|
||||
memset(s.f,0,sizeof(s.f));
|
||||
for(i=0;i<52;i++)
|
||||
s.f[i][i]=1;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
s=mul(s,a);
|
||||
a=mul(a,a);
|
||||
b=b>>1;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int i,j,k,n,a[100];
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<26;i++)
|
||||
{
|
||||
a[i]=i;
|
||||
a[i+26]=32+i;
|
||||
}
|
||||
matrix e,ee;
|
||||
memset(e.f,0,sizeof(e.f));
|
||||
memset(ee.f,0,sizeof(ee.f));
|
||||
for(j=0;j<52;j++)
|
||||
{
|
||||
for(i=0;i<52;i++)
|
||||
{
|
||||
if(abs(a[j]-a[i])<32)e.f[i][j]=1;
|
||||
if(abs(a[j]-a[i])<=32)ee.f[i][j]=1;
|
||||
}
|
||||
}
|
||||
e=pow_mod(e,n-1);
|
||||
ee=pow_mod(ee,n-1);
|
||||
LL ans=0;
|
||||
for(i=0;i<52;i++)
|
||||
{
|
||||
for(j=0;j<52;j++)
|
||||
{
|
||||
ans+=ee.f[i][j]-e.f[i][j];
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",(ans%mod+mod)%mod);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <stdio.h>
|
||||
#define MAX(a,b) (a>b?a:b)
|
||||
#define MIN(a,b) (a<b?a:b)
|
||||
using namespace std;
|
||||
#define maxn 15000
|
||||
struct point{
|
||||
double x,y;
|
||||
bool operator == (const point &a) const{
|
||||
return a.x==x && a.y==y;
|
||||
}
|
||||
}temp;
|
||||
struct line{
|
||||
point a,b;
|
||||
}po[maxn];
|
||||
int n;
|
||||
bool cmp(const line &a,const line &b){
|
||||
return a.a.x < b.a.x;
|
||||
}
|
||||
int function6(int l,int r){
|
||||
int i,k,j;
|
||||
for(i=l;i<=r;i++){
|
||||
for(j=l;j<=r;j++){
|
||||
if(i==j) continue;
|
||||
if(po[i].a==po[j].a || po[i].a==po[j].b) break;
|
||||
}
|
||||
if(j==r+1){ printf("6");return 0;}
|
||||
for(j=l;j<=r;j++){
|
||||
if(i==j) continue;
|
||||
if(po[i].b==po[j].a || po[i].b==po[j].b) break;
|
||||
}
|
||||
if(j==r+1){ printf("6");return 0;}
|
||||
}
|
||||
printf("0");
|
||||
return 0;
|
||||
}
|
||||
int function5(int l,int r){
|
||||
int i,j,k,count,t;
|
||||
line rec[10],tem;
|
||||
bool flag[10];
|
||||
memset(flag,false,sizeof(flag));
|
||||
t=0;
|
||||
for(i=l;i<=r;i++){
|
||||
count=0;
|
||||
for(j=l;j<=r;j++){
|
||||
if(i==j)continue;
|
||||
if(po[i].a==po[j].a || po[i].a==po[j].b)
|
||||
count++;
|
||||
}
|
||||
if(count==0){ rec[t]=po[i];flag[t++]=false;}
|
||||
if(count>=2){ printf("3"); return 0;}
|
||||
count=0;
|
||||
for(j=l;j<=r;j++){
|
||||
if(i==j)continue;
|
||||
if(po[i].b==po[j].a || po[i].b==po[j].b)
|
||||
count++;
|
||||
}
|
||||
if(count>=2){ printf("3"); return 0;}
|
||||
if(count==0){ rec[t]=po[i];flag[t++]=true;}
|
||||
}
|
||||
if(MIN(rec[0].a.y,rec[0].b.y) < MIN(rec[1].a.y,rec[1].b.y)){
|
||||
if(flag[0]){printf("2");return 0;}
|
||||
else {printf("5");return 0;}
|
||||
}
|
||||
else if(MIN(rec[0].a.y,rec[0].b.y) == MIN(rec[1].a.y,rec[1].b.y)){
|
||||
if(rec[0].a.x > rec[1].b.x){
|
||||
if(flag[0]){printf("2");return 0;}
|
||||
else {printf("5");return 0;}
|
||||
}
|
||||
else {
|
||||
if(flag[1]){printf("2");return 0;}
|
||||
else {printf("5");return 0;}
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(flag[1]){printf("2");return 0;}
|
||||
else {printf("5");return 0;}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main(){
|
||||
int i,j,k,l,r;
|
||||
double Max;
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%lf%lf%lf%lf",&po[i].a.x,&po[i].a.y,&po[i].b.x,&po[i].b.y);
|
||||
if(po[i].a.x > po[i].b.x)
|
||||
temp=po[i].a,po[i].a=po[i].b,po[i].b=temp;
|
||||
else if(po[i].a.x == po[i].b.x && po[i].a.y > po[i].b.y)
|
||||
temp=po[i].a,po[i].a=po[i].b,po[i].b=temp;
|
||||
}
|
||||
sort(po,po+n,cmp);
|
||||
l=0,r=0;
|
||||
Max=po[0].b.x;
|
||||
for(i=1;i<n;i++){
|
||||
if(po[i].a.x-Max > 5.0 || i==n-1){
|
||||
if(i!=n-1)
|
||||
r=i-1;
|
||||
else
|
||||
r=i;
|
||||
switch(r-l+1){
|
||||
case 2:printf("1");break;
|
||||
case 4:printf("4");break;
|
||||
case 3:printf("7");break;
|
||||
case 7:printf("8");break;
|
||||
case 6:function6(l,r);break;
|
||||
case 5:function5(l,r);break;
|
||||
default:while(1);
|
||||
}
|
||||
l=i;
|
||||
Max=po[i].b.x;
|
||||
}
|
||||
Max=MAX(Max,po[i].b.x);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN=1001;
|
||||
int a[MAXN];
|
||||
int b[MAXN];
|
||||
bool cmp(int a,int b)
|
||||
{
|
||||
return a>b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,t;
|
||||
int sum;
|
||||
while(scanf("%d%d",&n,&t)!=EOF)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&b[i]);
|
||||
sort(a,a+n);
|
||||
sort(b,b+n,cmp);
|
||||
sum=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
if(a[i]+b[i]-t>0)
|
||||
sum+=a[i]+b[i]-t;
|
||||
}
|
||||
printf("%d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,249 @@
|
|||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<stdlib.h>
|
||||
using namespace std;
|
||||
const int MAXN=550;
|
||||
const double eps=1e-8;
|
||||
struct Point
|
||||
{
|
||||
double x,y,z;
|
||||
Point(){}
|
||||
Point(double xx,double yy,double zz):x(xx),y(yy),z(zz){}
|
||||
Point operator -(const Point p1)
|
||||
{
|
||||
return Point(x-p1.x,y-p1.y,z-p1.z);
|
||||
}
|
||||
Point operator +(const Point p1)
|
||||
{
|
||||
return Point(x+p1.x,y+p1.y,z+p1.z);
|
||||
}
|
||||
Point operator *(const Point p)
|
||||
{
|
||||
return Point(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
|
||||
}
|
||||
Point operator *(double d)
|
||||
{
|
||||
return Point(x*d,y*d,z*d);
|
||||
}
|
||||
Point operator / (double d)
|
||||
{
|
||||
return Point(x/d,y/d,z/d);
|
||||
}
|
||||
double operator ^(Point p)
|
||||
{
|
||||
return (x*p.x+y*p.y+z*p.z);
|
||||
}
|
||||
};
|
||||
struct CH3D
|
||||
{
|
||||
struct face
|
||||
{
|
||||
int a,b,c;
|
||||
bool ok;
|
||||
};
|
||||
int n;
|
||||
Point P[MAXN];
|
||||
int num;
|
||||
face F[8*MAXN];
|
||||
int g[MAXN][MAXN];
|
||||
double vlen(Point a)
|
||||
{
|
||||
return sqrt(a.x*a.x+a.y*a.y+a.z*a.z);
|
||||
}
|
||||
Point cross(const Point &a,const Point &b,const Point &c)
|
||||
{
|
||||
return Point((b.y-a.y)*(c.z-a.z)-(b.z-a.z)*(c.y-a.y),
|
||||
(b.z-a.z)*(c.x-a.x)-(b.x-a.x)*(c.z-a.z),
|
||||
(b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x)
|
||||
);
|
||||
}
|
||||
double area(Point a,Point b,Point c)
|
||||
{
|
||||
return vlen((b-a)*(c-a));
|
||||
}
|
||||
double volume(Point a,Point b,Point c,Point d)
|
||||
{
|
||||
return (b-a)*(c-a)^(d-a);
|
||||
}
|
||||
double dblcmp(Point &p,face &f)
|
||||
{
|
||||
Point m=P[f.b]-P[f.a];
|
||||
Point n=P[f.c]-P[f.a];
|
||||
Point t=p-P[f.a];
|
||||
return (m*n)^t;
|
||||
}
|
||||
void deal(int p,int a,int b)
|
||||
{
|
||||
int f=g[a][b];
|
||||
face add;
|
||||
if(F[f].ok)
|
||||
{
|
||||
if(dblcmp(P[p],F[f])>eps)
|
||||
dfs(p,f);
|
||||
else
|
||||
{
|
||||
add.a=b;
|
||||
add.b=a;
|
||||
add.c=p;
|
||||
add.ok=true;
|
||||
g[p][b]=g[a][p]=g[b][a]=num;
|
||||
F[num++]=add;
|
||||
}
|
||||
}
|
||||
}
|
||||
void dfs(int p,int now)
|
||||
{
|
||||
F[now].ok=0;
|
||||
deal(p,F[now].b,F[now].a);
|
||||
deal(p,F[now].c,F[now].b);
|
||||
deal(p,F[now].a,F[now].c);
|
||||
}
|
||||
bool same(int s,int t)
|
||||
{
|
||||
Point &a=P[F[s].a];
|
||||
Point &b=P[F[s].b];
|
||||
Point &c=P[F[s].c];
|
||||
return fabs(volume(a,b,c,P[F[t].a]))<eps &&
|
||||
fabs(volume(a,b,c,P[F[t].b]))<eps &&
|
||||
fabs(volume(a,b,c,P[F[t].c]))<eps;
|
||||
}
|
||||
void create()
|
||||
{
|
||||
int i,j,tmp;
|
||||
face add;
|
||||
num=0;
|
||||
if(n<4)return;
|
||||
bool flag=true;
|
||||
for(i=1;i<n;i++)
|
||||
{
|
||||
if(vlen(P[0]-P[i])>eps)
|
||||
{
|
||||
swap(P[1],P[i]);
|
||||
flag=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)return;
|
||||
flag=true;
|
||||
for(i=2;i<n;i++)
|
||||
{
|
||||
if(vlen((P[0]-P[1])*(P[1]-P[i]))>eps)
|
||||
{
|
||||
swap(P[2],P[i]);
|
||||
flag=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)return;
|
||||
flag=true;
|
||||
for(int i=3;i<n;i++)
|
||||
{
|
||||
if(fabs((P[0]-P[1])*(P[1]-P[2])^(P[0]-P[i]))>eps)
|
||||
{
|
||||
swap(P[3],P[i]);
|
||||
flag=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)return;
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
add.a=(i+1)%4;
|
||||
add.b=(i+2)%4;
|
||||
add.c=(i+3)%4;
|
||||
add.ok=true;
|
||||
if(dblcmp(P[i],add)>0)swap(add.b,add.c);
|
||||
g[add.a][add.b]=g[add.b][add.c]=g[add.c][add.a]=num;
|
||||
F[num++]=add;
|
||||
}
|
||||
for(i=4;i<n;i++)
|
||||
{
|
||||
for(j=0;j<num;j++)
|
||||
{
|
||||
if(F[j].ok&&dblcmp(P[i],F[j])>eps)
|
||||
{
|
||||
dfs(i,j);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
tmp=num;
|
||||
for(i=num=0;i<tmp;i++)
|
||||
if(F[i].ok)
|
||||
F[num++]=F[i];
|
||||
}
|
||||
double area()
|
||||
{
|
||||
double res=0;
|
||||
if(n==3)
|
||||
{
|
||||
Point p=cross(P[0],P[1],P[2]);
|
||||
res=vlen(p)/2.0;
|
||||
return res;
|
||||
}
|
||||
for(int i=0;i<num;i++)
|
||||
res+=area(P[F[i].a],P[F[i].b],P[F[i].c]);
|
||||
return res/2.0;
|
||||
}
|
||||
double volume()
|
||||
{
|
||||
double res=0;
|
||||
Point tmp(0,0,0);
|
||||
for(int i=0;i<num;i++)
|
||||
res+=volume(tmp,P[F[i].a],P[F[i].b],P[F[i].c]);
|
||||
return fabs(res/6.0);
|
||||
}
|
||||
int triangle()
|
||||
{
|
||||
return num;
|
||||
}
|
||||
int polygon()
|
||||
{
|
||||
int i,j,res,flag;
|
||||
for(i=res=0;i<num;i++)
|
||||
{
|
||||
flag=1;
|
||||
for(j=0;j<i;j++)
|
||||
if(same(i,j))
|
||||
{
|
||||
flag=0;
|
||||
break;
|
||||
}
|
||||
res+=flag;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
Point barycenter()
|
||||
{
|
||||
Point ans(0,0,0),o(0,0,0);
|
||||
double all=0;
|
||||
for(int i=0;i<num;i++)
|
||||
{
|
||||
double vol=volume(o,P[F[i].a],P[F[i].b],P[F[i].c]);
|
||||
ans=ans+(o+P[F[i].a]+P[F[i].b]+P[F[i].c])/4.0*vol;
|
||||
all+=vol;
|
||||
}
|
||||
ans=ans/all;
|
||||
return ans;
|
||||
}
|
||||
double ptoface(Point p,int i)
|
||||
{
|
||||
return fabs(volume(P[F[i].a],P[F[i].b],P[F[i].c],p)/vlen((P[F[i].b]-P[F[i].a])*(P[F[i].c]-P[F[i].a])));
|
||||
}
|
||||
};
|
||||
CH3D hull;
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&hull.n)==1)
|
||||
{
|
||||
for(int i=0;i<hull.n;i++)
|
||||
{
|
||||
scanf("%lf%lf%lf",&hull.P[i].x,&hull.P[i].y,&hull.P[i].z);
|
||||
}
|
||||
hull.create();
|
||||
printf("%d\n",hull.polygon());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
#include <iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int N = 61;
|
||||
const int M = N * 15 * 6 * N + 10;
|
||||
int n,m,D;
|
||||
int s[M],h[M],u[M],d[M],l[M],r[M],col[M],row[M],ans[M],aans[N][3];
|
||||
int num;
|
||||
bool flag[N][N];
|
||||
map<int,int>lcm;
|
||||
bool vis[N];
|
||||
bool ok;
|
||||
int idx[6][6] = {
|
||||
{0,0,0,0,0,0},
|
||||
{0,1,0,0,0,0},
|
||||
{0,2,6,0,0,0},
|
||||
{0,3,7,10,0,0},
|
||||
{0,4,8,11,13,0},
|
||||
{0,5,9,12,14,15},
|
||||
};
|
||||
void init()
|
||||
{
|
||||
int i,c;
|
||||
memset(h,0,sizeof(h));
|
||||
memset(s,0,sizeof(s));
|
||||
memset(vis,false,sizeof(vis));
|
||||
memset(flag,false,sizeof(flag));
|
||||
c = D * n;
|
||||
for(i = 0;i <= c;i ++)
|
||||
{
|
||||
u[i] = d[i] = i;
|
||||
l[i] = (i + c) % (c + 1);
|
||||
r[i] = (i + 1) % (c + 1);
|
||||
}
|
||||
num = c + 1;
|
||||
lcm.clear();
|
||||
lcm[1] = 11;
|
||||
lcm[2] = 12;lcm[6] = 22;
|
||||
lcm[3] = 13;lcm[7] = 23;lcm[10] = 33;
|
||||
lcm[4] = 14;lcm[8] = 24;lcm[11] = 34;lcm[13] = 44;
|
||||
lcm[5] = 15;lcm[9] = 25;lcm[12] = 35;lcm[14] = 45;lcm[15] = 55;
|
||||
}
|
||||
void insert(int i,int j)
|
||||
{
|
||||
if(h[i])
|
||||
{
|
||||
r[num] = h[i];
|
||||
l[num] = l[h[i]];
|
||||
l[r[num]] = num;
|
||||
r[l[num]] = num;
|
||||
}
|
||||
else
|
||||
h[i] = l[num] = r[num] = num;
|
||||
s[j] ++;
|
||||
u[num] = u[j];
|
||||
d[num] = j;
|
||||
d[u[j]] = num;
|
||||
u[j] = num;
|
||||
col[num] = j;
|
||||
row[num] = i;
|
||||
num ++;
|
||||
}
|
||||
void remove(int x)
|
||||
{
|
||||
int i,j;
|
||||
l[r[x]] = l[x];
|
||||
r[l[x]] = r[x];
|
||||
for(i = d[x];i != x;i = d[i])
|
||||
for(j = r[i];j != i;j = r[j])
|
||||
{
|
||||
u[d[j]] = u[j];
|
||||
d[u[j]] = d[j];
|
||||
s[col[j]] --;
|
||||
}
|
||||
}
|
||||
void resume(int x)
|
||||
{
|
||||
int i,j;
|
||||
for(i = u[x];i != x;i = u[i])
|
||||
for(j = l[i];j != i;j = l[j])
|
||||
{
|
||||
s[col[j]] ++;
|
||||
u[d[j]] = d[u[j]] = j;
|
||||
}
|
||||
l[r[x]] = r[l[x]] = x;
|
||||
}
|
||||
void dfs(int k)
|
||||
{
|
||||
if(ok)
|
||||
return;
|
||||
int i,j;
|
||||
if(!r[0])
|
||||
{
|
||||
ok = true;
|
||||
memset(aans,0,sizeof(aans));
|
||||
for(i = 0;i < k;i ++)
|
||||
{
|
||||
int ii = (ans[i] - 1)/15 + 1;
|
||||
int jj = ans[i] - (ii - 1) * 15;
|
||||
aans[ii][0] = lcm[jj]/10;
|
||||
aans[ii][1] = lcm[jj]%10;
|
||||
}
|
||||
for(i = 1;i <= n;i ++)
|
||||
printf("%d %d\n",aans[i][0],aans[i][1]);
|
||||
return;
|
||||
}
|
||||
int mx = M;
|
||||
int c;
|
||||
for(i = r[0];i;i = r[i])
|
||||
{
|
||||
if(s[i] < mx)
|
||||
{
|
||||
mx = s[i];
|
||||
c = i;
|
||||
}
|
||||
}
|
||||
remove(c);
|
||||
int tmp;
|
||||
for(i = d[c];i != c;i = d[i])
|
||||
{
|
||||
tmp = (row[i] - 1)/15 + 1;
|
||||
if(vis[tmp] == true)
|
||||
continue;
|
||||
vis[tmp] = true;
|
||||
ans[k] = row[i];
|
||||
for(j = r[i];j != i;j = r[j])
|
||||
remove(col[j]);
|
||||
dfs(k + 1);
|
||||
if(ok)
|
||||
return;
|
||||
for(j = l[i];j != i;j = l[j])
|
||||
resume(col[j]);
|
||||
vis[tmp] = false;
|
||||
}
|
||||
resume(c);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a,b,i,j,ii,jj,st,ed;
|
||||
while(scanf("%d",&n) != EOF)
|
||||
{
|
||||
scanf("%d%d",&m,&D);
|
||||
init();
|
||||
while(m --)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
flag[a][b] = flag[b][a] = true;
|
||||
}
|
||||
for(i = 1;i <= n;i ++)
|
||||
flag[i][i] = true;
|
||||
for(i = 1;i <= n;i ++)
|
||||
{
|
||||
scanf("%d%d",&st,&ed);
|
||||
int base = (i - 1) * 15;
|
||||
for(ii = st;ii <= ed;ii ++)
|
||||
{
|
||||
for(jj = st;jj <= ii;jj ++)
|
||||
{
|
||||
for(j = 1;j <= n;j ++)
|
||||
if(flag[i][j] == true)
|
||||
{
|
||||
for(int ai = jj;ai <= ii;ai ++)
|
||||
insert(base + idx[ii][jj],(j - 1) * D + ai);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ok = false;
|
||||
dfs(0);
|
||||
if(ok == false)
|
||||
puts("No solution");
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#define N 1005
|
||||
#define mod 1000000007
|
||||
#define ll __int64
|
||||
using namespace std;
|
||||
ll f[N][N];
|
||||
void init()
|
||||
{
|
||||
int i,j;
|
||||
for (i=1;i<N;i++)
|
||||
{
|
||||
f[i][0]=1;
|
||||
for (j=1;j<i;j++) f[i][j]=((j+1)*f[i-1][j]+(i-j)*f[i-1][j-1])%mod;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,k;
|
||||
init();
|
||||
while (scanf("%d%d",&n,&k)!=EOF) cout<<f[n][k]<<endl;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<stdio.h>
|
||||
#define INF 99999999
|
||||
int n,dis[15][15];
|
||||
int mark[15];
|
||||
void Floyed(){
|
||||
int i,j,k;
|
||||
for(k=0;k<n;k++)
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
if(dis[i][j]>dis[i][k]+dis[k][j])
|
||||
dis[i][j]=dis[i][k]+dis[k][j];
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
if(i==j)
|
||||
dis[i][j]=0;
|
||||
else
|
||||
dis[i][j]=INF;
|
||||
int m;
|
||||
int s,l;
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%d%d",&m,&mark[i]);
|
||||
for(j=0;j<m;j++){
|
||||
scanf("%d%d",&s,&l);
|
||||
dis[i][s]=l;
|
||||
}
|
||||
}
|
||||
Floyed();
|
||||
int min=INF;
|
||||
for(i=0;i<n;i++)
|
||||
if(mark[i])
|
||||
if(min>dis[0][i])
|
||||
min=dis[0][i];
|
||||
printf("%d\n",min);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
const int V = 808, E=400000;
|
||||
const double INF=1e5;
|
||||
double d[V],cost[E];
|
||||
int n,m,verNum;
|
||||
int head[V],pnt[E],nxt[E],e;
|
||||
int cnt[V];
|
||||
double u,l;
|
||||
void addedge(int u,int v,double c)
|
||||
{
|
||||
pnt[e]=v;
|
||||
cost[e]=c;
|
||||
nxt[e]=head[u];
|
||||
head[u]=e++;
|
||||
}
|
||||
bool relax(int u,int v,double w)
|
||||
{
|
||||
if(d[v]>d[u]+w)
|
||||
{
|
||||
d[v]=d[u]+w;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int spfa()
|
||||
{
|
||||
int vis[V];
|
||||
int i;
|
||||
//int Q[E];
|
||||
queue<int> Q;
|
||||
for(i=1;i<verNum;++i)
|
||||
{
|
||||
cnt[i] = 0;
|
||||
d[i]=INF;
|
||||
vis[i]=0;
|
||||
}
|
||||
vis[0]=1;
|
||||
d[0]=0;
|
||||
cnt[0] = 1;
|
||||
//int top=1;
|
||||
//Q[0]=0;
|
||||
Q.push(0);
|
||||
int u,v;
|
||||
double w;
|
||||
int nm = sqrt(verNum * 1.0); //涓寮归借跺澶╁ㄦ
|
||||
while(!Q.empty())
|
||||
{
|
||||
//u=Q[--top];
|
||||
u = Q.front();
|
||||
Q.pop();
|
||||
vis[u]=0;
|
||||
for(i=head[u];i!=-1;i=nxt[i])
|
||||
{
|
||||
v=pnt[i];
|
||||
w=cost[i];
|
||||
if(relax(u,v,w) && !vis[v])
|
||||
{
|
||||
if(++cnt[v] > nm)
|
||||
return 0;
|
||||
//Q[top++]=v;
|
||||
Q.push(v);
|
||||
vis[v]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d%lf%lf",&n,&m,&l,&u) == 4)
|
||||
{
|
||||
double c,ll = log(l),uu = log(u);
|
||||
int i,j;
|
||||
verNum = n + m;
|
||||
memset(head,-1,sizeof(head));
|
||||
e = 0;
|
||||
for(i = 0; i < n; ++i)
|
||||
for(j = 0; j < m; ++j)
|
||||
{
|
||||
scanf("%lf",&c);
|
||||
c = log(c);
|
||||
addedge(i,j+n,c-ll);
|
||||
addedge(j+n,i,uu-c);
|
||||
}
|
||||
if(spfa())
|
||||
printf("YES\n");
|
||||
else
|
||||
printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int N=300;
|
||||
int head[N];
|
||||
const int MAXE=5000000;
|
||||
const int inf=1<<30;
|
||||
int n,m,k;
|
||||
int cnt,s,t;
|
||||
int H[]={1,3,5,7,9};
|
||||
int d[N],pre[N];
|
||||
int ans=0;
|
||||
bool vis[N];
|
||||
int q[MAXE];
|
||||
struct Edge
|
||||
{
|
||||
int u,v,c,w,next;
|
||||
}edge[MAXE];
|
||||
void addedge(int u,int v,int w,int c)
|
||||
{
|
||||
edge[cnt].u=u;
|
||||
edge[cnt].v=v;
|
||||
edge[cnt].w=w;
|
||||
edge[cnt].c=c;
|
||||
edge[cnt].next=head[u];
|
||||
head[u]=cnt++;
|
||||
edge[cnt].v=u;
|
||||
edge[cnt].u=v;
|
||||
edge[cnt].w=-w;
|
||||
edge[cnt].c=0;
|
||||
edge[cnt].next=head[v];
|
||||
head[v]=cnt++;
|
||||
}
|
||||
int SPFA()
|
||||
{
|
||||
int l,r;
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(int i=0;i<=t;i++) d[i]=inf;
|
||||
d[s]=0;
|
||||
l=0;r=0;
|
||||
q[r++]=s;
|
||||
vis[s]=1;
|
||||
while(l<r)
|
||||
{
|
||||
int u=q[l++];
|
||||
vis[u]=0;
|
||||
for(int j=head[u];j!=-1;j=edge[j].next)
|
||||
{
|
||||
int v=edge[j].v;
|
||||
if(edge[j].c>0&&d[u]+edge[j].w<d[v])
|
||||
{
|
||||
d[v]=d[u]+edge[j].w;
|
||||
pre[v]=j;
|
||||
if(!vis[v])
|
||||
{
|
||||
vis[v]=1;
|
||||
q[r++]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(d[t]==inf)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
void MCMF()
|
||||
{
|
||||
int flow=0;
|
||||
while(SPFA())
|
||||
{
|
||||
int u=t;
|
||||
int mini=inf;
|
||||
while(u!=s)
|
||||
{
|
||||
if(edge[pre[u]].c<mini)
|
||||
mini=edge[pre[u]].c;
|
||||
u=edge[pre[u]].u;
|
||||
}
|
||||
flow+=mini;
|
||||
ans+=d[t]*mini;
|
||||
u=t;
|
||||
while(u!=s)
|
||||
{
|
||||
edge[pre[u]].c-=mini;
|
||||
edge[pre[u]^1].c+=mini;
|
||||
u=edge[pre[u]].u;
|
||||
}
|
||||
}
|
||||
if (flow<k)
|
||||
printf("-1\n");
|
||||
else
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%d%d%d",&n,&m,&k)!=EOF)
|
||||
{
|
||||
int u,v,c,w;
|
||||
cnt=0;
|
||||
s=0;
|
||||
t=n;
|
||||
ans=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
addedge(s,1,0,k);
|
||||
for (int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d%d%d%d",&u,&v,&w,&c);
|
||||
for (int j=0;j<c;j++)
|
||||
{
|
||||
addedge(u,v,H[j]*w,1);
|
||||
}
|
||||
}
|
||||
addedge(n,t,0,inf);
|
||||
MCMF();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const double PI = acos(-1.0);
|
||||
double H,R, volume,ans,total;
|
||||
int main(){
|
||||
while (scanf("%lf%lf",&R,&H) != EOF){
|
||||
total = 2*PI*R*R*H;
|
||||
if (H >= 2*R){
|
||||
volume = R*R*R*2/3;
|
||||
}
|
||||
else {
|
||||
volume = H*H*sqrt(R*R-H*H*1/4)*1/4 + R*R*R*2/3 - R*R*sqrt(R*R-H*H*1/4) + (R*R-H*H*1/4)*sqrt(R*R-H*H*1/4)*1/3;
|
||||
}
|
||||
ans = total - 8*volume;
|
||||
printf("%.4lf\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <iomanip>
|
||||
#define INF 1ll<<60
|
||||
typedef long long LL;
|
||||
using namespace std;
|
||||
const int MAX=50000+10;
|
||||
int n,k,index,head,tail,Id;
|
||||
LL dp[MAX][2],q[MAX];
|
||||
struct Node{
|
||||
LL w,h;
|
||||
bool operator<(const Node &a)const{
|
||||
return h>a.h;
|
||||
}
|
||||
}s[MAX];
|
||||
LL GetY(int k,int k2){
|
||||
return dp[k][index^1]-dp[k2][index^1];
|
||||
}
|
||||
LL GetX(int k,int k2){
|
||||
return s[k2+1].h-s[k+1].h;
|
||||
}
|
||||
void DP(){
|
||||
index=0;
|
||||
memset(dp,0,sizeof dp);
|
||||
for(int i=1;i<=n;++i)dp[i][index]=INF;
|
||||
for(int j=1;j<=k;++j){
|
||||
index=index^1;
|
||||
head=tail=0;
|
||||
q[tail++]=0;
|
||||
Id=0;
|
||||
for(int i=1;i<=n;++i){
|
||||
if(s[i].w <= s[Id].w)continue;
|
||||
Id=i;
|
||||
while(head+1<tail && GetY(q[head+1],q[head])<=GetX(q[head+1],q[head])*s[i].w)++head;
|
||||
dp[i][index]=dp[q[head]][index^1]+s[i].w*s[q[head]+1].h;
|
||||
while(head+1<tail && GetY(i,q[tail-1])*GetX(q[tail-1],q[tail-2])<=GetY(q[tail-1],q[tail-2])*GetX(i,q[tail-1]))--tail;
|
||||
q[tail++]=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%d%d",&n,&k)){
|
||||
for(int i=1;i<=n;++i)scanf("%I64d%I64d",&s[i].w,&s[i].h);
|
||||
sort(s+1,s+n+1);
|
||||
DP();
|
||||
printf("%I64d\n",dp[Id][index]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 65536, M = 101000;
|
||||
int p[20][M], n;
|
||||
int lowbit(int t)
|
||||
{
|
||||
return t&(t^(t-1));
|
||||
}
|
||||
int sum(int k, int end)
|
||||
{
|
||||
int ans = 0;
|
||||
end++;
|
||||
while(end > 0)
|
||||
{
|
||||
ans += p[k][end];
|
||||
end -= lowbit(end);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void add(int k, int pos, int num)
|
||||
{
|
||||
pos++;
|
||||
while(pos < M)
|
||||
{
|
||||
p[k][pos] += num;
|
||||
pos += lowbit(pos);
|
||||
}
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(p, 0, sizeof(p));
|
||||
int w, t;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
scanf("%d", &w);
|
||||
t = 0;
|
||||
while(t<16)
|
||||
{
|
||||
add(t,w%(1<<(t+1)),1);
|
||||
t++;
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve(int k)
|
||||
{
|
||||
LL ans = 0;
|
||||
int now = 0;
|
||||
char ss[10];
|
||||
int w, tail;
|
||||
while(scanf("%s", ss) && ss[0] != 'E')
|
||||
{
|
||||
scanf("%d", &w);
|
||||
if(ss[0] == 'C')
|
||||
{
|
||||
now += w;
|
||||
now %= N;
|
||||
}
|
||||
else
|
||||
{
|
||||
tail = now%(1<<w);
|
||||
if(now&(1<<w))
|
||||
{
|
||||
ans += sum(w, (1<<w)-tail-1);
|
||||
ans += sum(w, (1<<(w+1))-1) - sum(w,(1<<w+1)-tail-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
ans += sum(w, (1<<(w+1)) - tail-1) - sum(w, (1<<w)-1);
|
||||
ans += sum(w, (1<<w)-1) - sum(w, (1<<w)-tail-1 );
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %I64d\n", k, ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t=0;
|
||||
while(scanf("%d", &n) && n!=-1)
|
||||
{
|
||||
init();
|
||||
t++;
|
||||
solve(t);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 1050, M = 21000;
|
||||
struct EDGE
|
||||
{
|
||||
int u, v, next;
|
||||
}edge[M];
|
||||
int num, head[N], low[N], lp[N], step;
|
||||
int n, m, ans=0, f, root;
|
||||
void add(int u, int v)
|
||||
{
|
||||
edge[num].u = u;
|
||||
edge[num].v = v;
|
||||
edge[num].next = head[u];
|
||||
head[u] = num++;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
num = 0;
|
||||
memset(head, -1, sizeof(head));
|
||||
int u, v;
|
||||
for(int i=0; i<m; i++)
|
||||
{
|
||||
scanf("%d%d", &u, &v);
|
||||
add(u, v);
|
||||
add(v, u);
|
||||
}
|
||||
}
|
||||
int tarjan(int u)
|
||||
{
|
||||
lp[u] = low[u] = ++step;
|
||||
int tp = 0,v, cc=1;
|
||||
bool flag = 0;
|
||||
for(int i = head[u];i != -1;i = edge[i].next)
|
||||
{
|
||||
v = edge[i].v;
|
||||
if(v == f) continue;
|
||||
if(!lp[v])
|
||||
{
|
||||
cc++;
|
||||
tp++;
|
||||
tarjan(v);
|
||||
low[u] = min(low[u],low[v]);
|
||||
if(u != root&&lp[u] <= low[v])
|
||||
flag = 1;
|
||||
}
|
||||
else low[u] = min(low[u],lp[v]);
|
||||
}
|
||||
if(u == root && tp > 1)
|
||||
flag = 1;
|
||||
if(flag) ans++;
|
||||
return cc;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int result = 0;
|
||||
int now, path[N] = {0};
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
memset(low, 0, sizeof(low));
|
||||
memset(lp, 0, sizeof(lp));
|
||||
step = 1;
|
||||
now = ans = 0;
|
||||
f = i;
|
||||
for(int j=1; j<=n; j++)
|
||||
{
|
||||
if(!lp[j] && j!=i)
|
||||
{
|
||||
root = j;
|
||||
path[++now] = tarjan(j);
|
||||
}
|
||||
}
|
||||
if(now > 2) result += n-1;
|
||||
else if(now == 2)
|
||||
{
|
||||
sort(path+1, path+3);
|
||||
if(path[1] == 1)
|
||||
{
|
||||
if(path[2] != 1)
|
||||
result += n-2;
|
||||
}
|
||||
else result += n-1;
|
||||
}
|
||||
else result += ans;
|
||||
}
|
||||
printf("%d\n", result/2);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t=0;
|
||||
while(scanf("%d%d", &n, &m) != EOF)
|
||||
{
|
||||
if(n==0 && m==0)
|
||||
break;
|
||||
init();
|
||||
t++;
|
||||
printf("Case %d: ", t);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
#define MAXN 600
|
||||
#define INF 0x3f3f3f3f
|
||||
struct Node{
|
||||
int v,e;
|
||||
Node *next;
|
||||
}*edge[MAXN],space[MAXN<<1];
|
||||
int f[MAXN][MAXN][2],C,son[MAXN];
|
||||
void addedge(int x,int y,int z){
|
||||
Node *p=&space[C++];
|
||||
p->v=x; p->e=z; p->next=edge[y];
|
||||
edge[y]=p;
|
||||
}
|
||||
void dfs(int x,int fa){
|
||||
f[x][1][0]=0; f[x][1][1]=0;
|
||||
son[x]=1;
|
||||
for (Node *p=edge[x]; p; p=p->next){
|
||||
if (p->v!=fa){
|
||||
int y=p->v;
|
||||
dfs(y,x);
|
||||
son[x]+=son[y];
|
||||
for (int i=son[x];i>1;i--)
|
||||
for (int j=1;j<=son[y];j++){
|
||||
f[x][i][0]=min(f[x][i][0],f[x][i-j][0]+f[y][j][0]+(p->e)*2);
|
||||
f[x][i][1]=min(f[x][i][1],f[x][i-j][0]+f[y][j][1]+p->e);
|
||||
f[x][i][1]=min(f[x][i][1],f[x][i-j][1]+f[y][j][0]+(p->e)*2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int caseT=0,x,y,z,n,Q,t;
|
||||
while (scanf("%d",&n),n){
|
||||
C=0;
|
||||
for (int i=0;i<=n;i++) edge[i]=NULL;
|
||||
for (int i=1;i<n;i++){
|
||||
scanf("%d%d%d",&x,&y,&z);
|
||||
addedge(x+1,y+1,z); addedge(y+1,x+1,z);
|
||||
}
|
||||
memset(son,0,sizeof(son));
|
||||
for (int i=0;i<=n;i++)
|
||||
for (int j=0;j<=n;j++) f[i][j][0]=f[i][j][1]=INF;
|
||||
dfs(1,0);
|
||||
scanf("%d",&Q);
|
||||
printf("Case %d:\n",++caseT);
|
||||
for (int i=1;i<=Q;i++){
|
||||
scanf("%d",&t);
|
||||
int ans=1;
|
||||
for (int i=n;i>=1;i--){
|
||||
if (f[1][i][0]<=t||f[1][i][1]<=t){
|
||||
ans=i; break;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<iostream>
|
||||
#include<set>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int n,ans;
|
||||
unsigned int m;
|
||||
int l[2000000];
|
||||
int t[2000000];
|
||||
int a[200000];
|
||||
struct cmp
|
||||
{
|
||||
bool operator()(int x,int y)const
|
||||
{
|
||||
if(l[x]<l[y])return true;
|
||||
else if(l[x]==l[y]&&t[x]>t[y]) return true;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
set<int,cmp> myset;
|
||||
set<int,cmp>::reverse_iterator it;
|
||||
int main()
|
||||
{
|
||||
int sec=0;
|
||||
while(scanf("%u%d",&m,&n),m||n)
|
||||
{
|
||||
sec++;ans=0;
|
||||
myset.clear();
|
||||
memset(l,0,sizeof(l));
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(myset.count(a[i])==0)
|
||||
{
|
||||
if(myset.size()<m)
|
||||
{
|
||||
l[a[i]]=1;t[a[i]]=i;myset.insert(a[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
ans++;
|
||||
it=myset.rbegin();
|
||||
myset.erase(*it);
|
||||
l[a[i]]=1;t[a[i]]=i;myset.insert(a[i]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
myset.erase(a[i]);
|
||||
l[a[i]]++;
|
||||
myset.insert(a[i]);
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d\n",sec,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#define N 200009
|
||||
typedef long long LL;
|
||||
using namespace std;
|
||||
int n,m,a[N],b[N],c[N],L[N],R[N];
|
||||
LL d[N],s1[N],s2[N],sum[N];
|
||||
LL max(LL aa, LL bb)
|
||||
{
|
||||
if(aa > bb)return aa;
|
||||
return bb;
|
||||
}
|
||||
void make()
|
||||
{
|
||||
int i,j,k,l;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
k = i-1;
|
||||
while(k > 0 && a[k] <= a[i])k = b[k];
|
||||
b[i] = k;
|
||||
}
|
||||
for(i=n;i>0;i--)
|
||||
{
|
||||
k = i+1;
|
||||
while(k <= n && a[k] <= a[i])k = c[k];
|
||||
c[i] = k;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,l,cas=0;
|
||||
while(scanf("%d %d",&n,&m) != EOF)
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
sum[0] = 0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
sum[i] = sum[i-1] + a[i];
|
||||
}
|
||||
make();
|
||||
L[1] = a[1]; for(i=2;i<=n;i++) { L[i] = a[i]; if(L[i] < L[i-1])L[i] = L[i-1]; }
|
||||
R[n] = a[n]; for(i=n-1;i>0;i--) { R[i] = a[i]; if(R[i] < R[i+1])R[i] = R[i+1]; }
|
||||
s1[1] = 0;
|
||||
for(i=2;i<=n;i++)
|
||||
{
|
||||
s1[i] = s1[i-1] + max(L[i-1] - a[i], 0);
|
||||
}
|
||||
s2[n] = 0;
|
||||
for(i=n-1;i>0;i--)
|
||||
{
|
||||
s2[i] = s2[i+1] + max(R[i+1] - a[i], 0);
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
d[i] = 0;
|
||||
k = b[i];
|
||||
if(k < 1)d[i] += s1[i];
|
||||
else
|
||||
{
|
||||
l = i-k-1; d[i] += (LL)l*a[i] - (sum[i-1]-sum[k]);
|
||||
}
|
||||
k = c[i];
|
||||
if(k > n)d[i] += s2[i];
|
||||
else
|
||||
{
|
||||
l = k-i-1; d[i] += (LL)l*a[i] - (sum[k-1]-sum[i]);
|
||||
}
|
||||
}
|
||||
sort(d+1, d+1+n);
|
||||
printf("Case %d: %I64d\n",++cas,d[n-m+1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
const int Mod=9973;
|
||||
int cnt[2],box[2][Mod],now,pre;
|
||||
struct edge{
|
||||
int to,next,num;
|
||||
} e[2][120000];
|
||||
void add(int u,int num)
|
||||
{
|
||||
int idx=u%Mod;
|
||||
for(int p=box[pre][idx];p!=-1;p=e[pre][p].next)
|
||||
if (e[pre][p].to==u)
|
||||
{
|
||||
if (e[pre][p].num>num) e[pre][p].num=num;
|
||||
return ;
|
||||
}
|
||||
e[pre][cnt[pre]].to=u;e[pre][cnt[pre]].num=num;
|
||||
e[pre][cnt[pre]].next=box[pre][idx];box[pre][idx]=cnt[pre]++;
|
||||
}
|
||||
int a[100][20];
|
||||
int b[20];
|
||||
int base[20];
|
||||
bool ok1(int i,int j)
|
||||
{
|
||||
return (a[i][j]>a[i][j-1]&&a[i][j-1]>a[i][j-2])||
|
||||
(a[i][j]<a[i][j-1]&&a[i][j-1]<a[i][j-2]);
|
||||
}
|
||||
bool ok2(int i,int j)
|
||||
{
|
||||
return (a[i][j]>a[i-1][j]&&a[i-1][j]>a[i-2][j])||
|
||||
(a[i][j]<a[i-1][j]&&a[i-1][j]<a[i-2][j]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int T=0;
|
||||
base[0]=1;
|
||||
for(int i=1;i<=10;i++) base[i]=base[i-1]<<2;
|
||||
while(scanf("%d %d",&n,&m)==2)
|
||||
{
|
||||
if (n==0&&m==0) break;
|
||||
memset(box[0],-1,sizeof(box[0]));
|
||||
cnt[0]=0;
|
||||
now=1;pre=0;
|
||||
add(0,0);
|
||||
now=0;pre=1;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&a[i][j]);
|
||||
memset(box[pre],-1,sizeof(box[pre]));
|
||||
cnt[pre]=0;
|
||||
for(int p=0;p<cnt[now];p++)
|
||||
{
|
||||
int v=e[now][p].to;
|
||||
int tmp=v;
|
||||
int num=e[now][p].num;
|
||||
int k=0;
|
||||
while(v)
|
||||
{
|
||||
b[k++]=v&3;
|
||||
v>>=2;
|
||||
}
|
||||
while(k<=m) b[k++]=0;
|
||||
tmp-=b[j+1]*base[j+1]+b[0];
|
||||
if (i==0) b[j+1]=0;
|
||||
if (j==0) b[0]=0;
|
||||
if (a[i][j]<=0)
|
||||
{
|
||||
add(tmp,num);
|
||||
continue;
|
||||
}
|
||||
if (b[0]==0) add(tmp+1,num+1); else
|
||||
if (b[0]==1&&a[i][j]!=a[i][j-1]) add(tmp+2,num) ; else
|
||||
if (ok1(i,j)) add(tmp+2,num); else
|
||||
add(tmp+1,num+1);
|
||||
if (b[j+1]==0) add(tmp+base[j+1],num+1); else
|
||||
if (b[j+1]==1&&a[i][j]!=a[i-1][j]) add(tmp+2*base[j+1],num); else
|
||||
if (ok2(i,j)) add(tmp+2*base[j+1],num); else
|
||||
add(tmp+base[j+1],num+1);
|
||||
}
|
||||
now^=1;pre^=1;
|
||||
}
|
||||
int ans=n*m;
|
||||
for(int i=0;i<cnt[now];i++)
|
||||
if (ans>e[now][i].num) ans=e[now][i].num;
|
||||
printf("Case %d: %d\n",++T,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int L,N,i,T,a[10];
|
||||
int t=0,time;
|
||||
while(cin>>L>>N>>T)
|
||||
{
|
||||
if(L==0) break;
|
||||
for(i=0;i<N;i++)
|
||||
cin>>a[i];
|
||||
sort(a,a+N);
|
||||
time=T*(N-1)+L/a[0];
|
||||
cout<<"Case "<<++t<<": "<<time<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<set>
|
||||
#include<vector>
|
||||
#include<map>
|
||||
#include<complex>
|
||||
using namespace std;
|
||||
typedef long long lld;
|
||||
#define pb push_back
|
||||
#define mp make_pair
|
||||
#define X first
|
||||
#define Y second
|
||||
lld s[2010];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int cc=1;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
if(n == 0)
|
||||
break;
|
||||
lld sum=0;
|
||||
bool zero=true;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%I64d",&s[i]);
|
||||
s[i+n]=s[i];
|
||||
sum+=s[i];
|
||||
if(s[i] != 0)
|
||||
zero=false;
|
||||
}
|
||||
if(sum < 0)
|
||||
{
|
||||
printf("Case %d: -1\n",cc++);
|
||||
continue;
|
||||
}
|
||||
if(sum == 0 && !zero)
|
||||
{
|
||||
printf("Case %d: -1\n",cc++);
|
||||
continue;
|
||||
}
|
||||
lld ans=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
lld now=0;
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
now+=s[i+j];
|
||||
if(now < 0)
|
||||
{
|
||||
lld x=-now/sum;
|
||||
if(x*sum != -now)
|
||||
x++;
|
||||
ans+=x;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %I64d\n",cc++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int a[4][1000],b;
|
||||
int n,i,j,count,t;
|
||||
t=0;
|
||||
while(cin>>n)
|
||||
{
|
||||
count=0;
|
||||
if(n==0) break;
|
||||
for(i=1;i<3;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
cin>>b;
|
||||
if(i<3)
|
||||
a[i][b]=j;
|
||||
}
|
||||
for(j=1;j<=n;j++)
|
||||
cin>>a[3][j];
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(a[1][j]<=a[3][j])
|
||||
count=count+3;
|
||||
else
|
||||
{
|
||||
if(a[1][j]<a[2][j])
|
||||
count=count+2;
|
||||
else
|
||||
count=count+1;
|
||||
}
|
||||
}
|
||||
cout<<"Case "<<++t<<": "<<count<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
char gp[16][16];
|
||||
int nd[16][2],dp[1<<16][16],n,m,fis,ac,cnt=0,dis[16][16];
|
||||
int dr[4][2]={1,0,-1,0,0,1,0,-1};
|
||||
int bfs(int x,int y,int xx,int yy)
|
||||
{
|
||||
queue<int> a,b;
|
||||
int vd[16][16];
|
||||
memset(vd,-1,sizeof(vd));
|
||||
if(xx==x&&y==yy) return 0;
|
||||
a.push(x);
|
||||
b.push(y);
|
||||
vd[x][y]=0;
|
||||
while(a.empty()==0)
|
||||
{
|
||||
int nx=a.front(),ny=b.front();
|
||||
a.pop();b.pop();
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
int dx=nx+dr[i][0],dy=ny+dr[i][1];
|
||||
if(dx<0||dx>=n||dy<0||dy>=m||vd[dx][dy]!=-1||gp[dx][dy]=='D')continue;
|
||||
vd[dx][dy]=vd[nx][ny]+1;
|
||||
a.push(dx);b.push(dy);
|
||||
if(dx==xx&&dy==yy)return vd[dx][dy];
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
bool check(int gs)
|
||||
{
|
||||
memset(dp,-1,sizeof(dp));
|
||||
dp[1<<fis][fis]=gs;
|
||||
int ans=-1;
|
||||
for(int i=0;i<(1<<cnt);i++)
|
||||
for(int j=0;j<cnt;j++)
|
||||
{
|
||||
if((i&(1<<j))==0)continue;
|
||||
if((i&(ac))==ac)
|
||||
if(dp[i][j]!=-1)
|
||||
return true;
|
||||
for(int k=0;k<cnt;k++)
|
||||
{
|
||||
if(dp[i][j]==-1||k==j||(i&(1<<k))||dis[j][k]==-1)continue;
|
||||
int tem=dp[i][j]-dis[j][k];
|
||||
if(tem<0)continue;
|
||||
dp[i+(1<<k)][k]=max(dp[i+(1<<k)][k],tem);
|
||||
if(gp[nd[k][0]][nd[k][1]]=='G')dp[i+(1<<k)][k]=gs;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i,j;
|
||||
for(int i=0;i<cnt;i++)
|
||||
for(int j=0;j<cnt;j++)
|
||||
{
|
||||
if(i==j)dis[i][j]=0;
|
||||
else
|
||||
dis[i][j]=bfs(nd[i][0],nd[i][1],nd[j][0],nd[j][1]);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int l,r,mid;
|
||||
while(1)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
if(n==0&&m==0)return 0;
|
||||
getchar();
|
||||
ac=0;cnt=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
scanf("%c",&gp[i][j]);
|
||||
if(gp[i][j]=='F')
|
||||
{
|
||||
fis=cnt;
|
||||
nd[cnt][0]=i;
|
||||
nd[cnt][1]=j;
|
||||
ac+=1<<cnt;
|
||||
cnt++;
|
||||
}
|
||||
else
|
||||
if(gp[i][j]=='G')
|
||||
{
|
||||
nd[cnt][0]=i;
|
||||
nd[cnt][1]=j;
|
||||
cnt++;
|
||||
}
|
||||
else
|
||||
if(gp[i][j]=='Y')
|
||||
{
|
||||
nd[cnt][0]=i;
|
||||
nd[cnt][1]=j;
|
||||
ac+=1<<cnt;
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
getchar();
|
||||
}
|
||||
init();
|
||||
l=0,r=300;
|
||||
int ans=1<<30;
|
||||
while(l<=r)
|
||||
{
|
||||
mid=(l+r)/2;
|
||||
if(check(mid))
|
||||
{
|
||||
r=mid-1;
|
||||
ans=min(mid,ans);
|
||||
}
|
||||
else
|
||||
l=mid+1;
|
||||
}
|
||||
if(ans==(1<<30))
|
||||
printf("-1\n");
|
||||
else
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 1001
|
||||
int num[MAXN*MAXN];
|
||||
int main(int argc, char** argv) {
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
int n, m;
|
||||
scanf("%d%d", &n, &m);
|
||||
getchar();
|
||||
char a, b;
|
||||
int valA, valB;
|
||||
int len = 0, i;
|
||||
while (m--) {
|
||||
scanf("%c=%d,%c=%d", &a, &valA, &b, &valB);
|
||||
getchar();
|
||||
if (a == 'X') {
|
||||
if (b == 'Y')
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = valA * n * n + valB * n + i;
|
||||
else
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = valA * n * n + i * n + valB;
|
||||
} else if (a == 'Y') {
|
||||
if (b == 'X')
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = valB * n * n + valA * n + i;
|
||||
else
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = i * n * n + valA * n + valB;
|
||||
} else {
|
||||
if (b == 'X')
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = valB * n * n + i * n + valA;
|
||||
else
|
||||
for (i = 1; i <= n; ++i)
|
||||
num[len++] = i * n * n + valB * n + valA;
|
||||
}
|
||||
}
|
||||
sort(num, num + len);
|
||||
int sum(1);
|
||||
int p = 0;
|
||||
for (i = 1; i < len; ++i) {
|
||||
if (num[i] != num[p])
|
||||
p = i, ++sum;
|
||||
}
|
||||
printf("%d\n", sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int a[20][20],nx,ny;
|
||||
char b[][10]={"white","black"};
|
||||
int judge(int now)
|
||||
{
|
||||
int i,j;
|
||||
for(i=0;i<15;i++)
|
||||
for(j=0;j<15;j++)
|
||||
{
|
||||
if(i<11&&j<11)
|
||||
if(a[i][j]==now&&a[i+1][j+1]==now
|
||||
&&a[i+2][j+2]==now&&a[i+3][j+3]==now
|
||||
&&a[i+4][j+4]==now)
|
||||
return 1;
|
||||
if(i<11)
|
||||
if(a[i][j]==now&&a[i+1][j]==now
|
||||
&&a[i+2][j]==now&&a[i+3][j]==now
|
||||
&&a[i+4][j]==now)
|
||||
return 1;
|
||||
if(j<11)
|
||||
if(a[i][j]==now&&a[i][j+1]==now
|
||||
&&a[i][j+2]==now&&a[i][j+3]==now
|
||||
&&a[i][j+4]==now)
|
||||
return 1;
|
||||
if(i>3&&j<11)
|
||||
if(a[i][j]==now&&a[i-1][j+1]==now
|
||||
&&a[i-2][j+2]==now&&a[i-3][j+3]==now
|
||||
&&a[i-4][j+4]==now)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int judge1(int now)
|
||||
{
|
||||
int i,j,num=0,ok;
|
||||
for(i=0;i<15;i++)
|
||||
for(j=0;j<15;j++)
|
||||
if(a[i][j]<0)
|
||||
{
|
||||
a[i][j]=now;
|
||||
ok=judge(now);
|
||||
a[i][j]=-1;
|
||||
if(ok)
|
||||
{
|
||||
nx=i;
|
||||
ny=j;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int judge2(int now)
|
||||
{
|
||||
int i,j,num=0,ok;
|
||||
for(i=0;i<15;i++)
|
||||
for(j=0;j<15;j++)
|
||||
if(a[i][j]<0)
|
||||
{
|
||||
a[i][j]=!now;
|
||||
ok=judge(!now);
|
||||
a[i][j]=-1;
|
||||
if(ok)
|
||||
{
|
||||
num++;
|
||||
nx=i;
|
||||
ny=j;
|
||||
if(num==2)
|
||||
return num;
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
int judge3(int now)
|
||||
{
|
||||
int i,j,ok;
|
||||
if(judge2(now)==1)
|
||||
{
|
||||
i=nx;
|
||||
j=ny;
|
||||
a[i][j]=now;
|
||||
if(judge2(!now)==2)
|
||||
{
|
||||
nx=i;
|
||||
ny=j;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
for(i=0;i<15;i++)
|
||||
for(j=0;j<15;j++)
|
||||
if(a[i][j]<0)
|
||||
{
|
||||
a[i][j]=now;
|
||||
ok=judge2(!now);
|
||||
a[i][j]=-1;
|
||||
if(ok==2)
|
||||
{
|
||||
nx=i;
|
||||
ny=j;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n,x,y,now;
|
||||
while(1)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
if(n==0)
|
||||
break;
|
||||
memset(a,-1,sizeof(a));
|
||||
now=1;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d%d%d",&x,&y,&k);
|
||||
if(k)
|
||||
now--;
|
||||
else
|
||||
now++;
|
||||
a[x][y]=k;
|
||||
}
|
||||
if(now!=0&&now!=1)
|
||||
{
|
||||
printf("Invalid.\n");
|
||||
continue;
|
||||
}
|
||||
if(n<=5)
|
||||
{
|
||||
printf("Cannot win in 3 moves.\n");
|
||||
continue;
|
||||
}
|
||||
if(judge1(now))
|
||||
printf("Place %s at (%d,%d) to win in 1 move.\n",b[now],nx,ny);
|
||||
else if(judge2(now)==2)
|
||||
printf("Lose in 2 moves.\n");
|
||||
else if(judge3(now))
|
||||
printf("Place %s at (%d,%d) to win in 3 moves.\n",b[now],nx,ny);
|
||||
else
|
||||
printf("Cannot win in 3 moves.\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,200 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
typedef struct pnode
|
||||
{
|
||||
double x,y,d;
|
||||
pnode( double a, double b ) {x = a;y = b;}
|
||||
pnode(){};
|
||||
}point;
|
||||
point P[ 105 ][ 1005 ];
|
||||
point P0,Pn;
|
||||
int Q[ 105 ];
|
||||
int top[ 105 ];
|
||||
typedef struct lnode
|
||||
{
|
||||
double x,y,dx,dy,d;
|
||||
int id,hit,sign;
|
||||
lnode( point a, point b ) {x = a.x;y = a.y;dx = b.x-a.x;dy = b.y-a.y;}
|
||||
lnode(){};
|
||||
}line;
|
||||
line L[ 10005 ];
|
||||
typedef struct knode
|
||||
{
|
||||
int size;
|
||||
line l[ 1005 ];
|
||||
point a[ 1005 ];
|
||||
point b[ 1005 ];
|
||||
}slope;
|
||||
slope S[ 105 ];
|
||||
double dist( point a, point b )
|
||||
{
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
double dist( point a, line l )
|
||||
{
|
||||
return fabs(l.dx*(a.y-l.y)-l.dy*(a.x-l.x))/sqrt(l.dx*l.dx+l.dy*l.dy);
|
||||
}
|
||||
double crossproduct( point a, point b, point c )
|
||||
{
|
||||
return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);
|
||||
}
|
||||
double parameter( line l, point a )
|
||||
{
|
||||
if ( l.dx ) return (a.x-l.x)/l.dx*l.sign;
|
||||
else return (a.y-l.y)/l.dy*l.sign;
|
||||
}
|
||||
bool l_cross_l( line a, line b )
|
||||
{
|
||||
double t1 = b.dx*(a.y-b.y)-b.dy*(a.x-b.x);
|
||||
double t2 = b.dx*(a.y+a.dy-b.y)-b.dy*(a.x+a.dx-b.x);
|
||||
return t1*t2 <= 0;
|
||||
}
|
||||
point crosspoint( line l, point a, point b )
|
||||
{
|
||||
line m = line( a, b );
|
||||
if ( m.dx*l.dy == m.dy*l.dx ) {
|
||||
if ( dist( point( l.x, l.y ), a ) < dist( point( l.x, l.y ), b ) )
|
||||
return a;
|
||||
else return b;
|
||||
}else {
|
||||
double a1 = -l.dy,b1 = l.dx,c1 = l.dx*l.y-l.dy*l.x;
|
||||
double a2 = -m.dy,b2 = m.dx,c2 = m.dx*m.y-m.dy*m.x;
|
||||
double x = (c1*b2-c2*b1)/(a1*b2-a2*b1);
|
||||
double y = (c1*a2-c2*a1)/(b1*a2-b2*a1);
|
||||
return point( x, y );
|
||||
}
|
||||
}
|
||||
double angle( line a, line b )
|
||||
{
|
||||
return (a.dx*b.dx+a.dy*b.dy)/sqrt(a.dx*a.dx+a.dy*a.dy)/sqrt(b.dx*b.dx+b.dy*b.dy);
|
||||
}
|
||||
bool cmp1( point a, point b )
|
||||
{
|
||||
if ( a.x == b.x ) return a.y < b.y;
|
||||
else return a.x < b.x;
|
||||
}
|
||||
bool cmp2( point a, point b )
|
||||
{
|
||||
double cp = crossproduct( P0, a, b );
|
||||
if ( cp == 0 ) return a.d < b.d;
|
||||
else return cp > 0;
|
||||
}
|
||||
bool cmp3( line a, line b )
|
||||
{
|
||||
return a.dy*b.dx < b.dy*a.dx;
|
||||
}
|
||||
bool cmp4( line a, line b )
|
||||
{
|
||||
return a.id < b.id;
|
||||
}
|
||||
void Graham( int N, int M )
|
||||
{
|
||||
point *p,q;
|
||||
double d1,d2,a1,a2;
|
||||
for ( int i = 0 ; i < N ; ++ i ) {
|
||||
p = &P[i][0];
|
||||
sort( p+0, p+Q[i], cmp1 );
|
||||
P0 = p[0];
|
||||
for ( int j = 1 ; j < Q[i] ; ++ j )
|
||||
p[j].d = dist( P0, p[j] );
|
||||
sort( p+1, p+Q[i], cmp2 );
|
||||
if ( Q[i] > 2 ) {
|
||||
int top = 2;
|
||||
for ( int j = 3 ; j < Q[i] ; ++ j ) {
|
||||
while ( top > 0 && crossproduct( p[top-1], p[top], p[j] ) <= 0 ) -- top;
|
||||
p[++ top] = p[j];
|
||||
}
|
||||
p[++ top] = p[0];
|
||||
int now = 1;
|
||||
for ( int j = 2 ; j <= top ; ++ j )
|
||||
if ( crossproduct( p[now-1], p[now], p[j] ) == 0 ) p[now] = p[j];
|
||||
else p[++ now] = p[j];
|
||||
Q[i] = now;
|
||||
}
|
||||
int L1 = 0,L2 = 0;
|
||||
if ( Q[i] > 1 ) L2 = 1;
|
||||
for ( int j = 1 ; j < Q[i] ; ++ j )
|
||||
if ( p[j].x > p[(j+1)%Q[i]].x ) {
|
||||
L2 = j;break;
|
||||
}
|
||||
int Ln = L2;
|
||||
line lt = line( point(0,0), point(0,-1) );
|
||||
S[i].size = -1;
|
||||
while ( p[L1].x <= p[(L1+1)%Q[i]].x || p[L2].x >= p[(L2+1)%Q[i]].x ) {
|
||||
a1 = angle( lt, line( p[L1], p[(L1+1)%Q[i]] ) );
|
||||
a2 = angle( lt, line( p[(L2+1)%Q[i]], p[L2] ) );
|
||||
S[i].size ++;
|
||||
S[i].a[S[i].size] = p[L1];
|
||||
S[i].b[S[i].size] = p[L2];
|
||||
if ( a1 > a2 && p[L1].x <= p[(L1+1)%Q[i]].x ) {
|
||||
lt = line( p[L1], p[(L1+1)%Q[i]] );
|
||||
L1 = (L1+1)%Q[i];
|
||||
}else {
|
||||
lt = line( p[(L2+1)%Q[i]], p[L2] );
|
||||
L2 = (L2+1)%Q[i];
|
||||
}
|
||||
S[i].l[S[i].size] = lt;
|
||||
}
|
||||
S[i].size ++;
|
||||
S[i].a[S[i].size] = p[0];
|
||||
S[i].b[S[i].size] = p[Ln];
|
||||
S[i].l[S[i].size] = line( point(0,0), point(0,1) );
|
||||
}
|
||||
int now[101];
|
||||
for ( int i = 0 ; i < N ; ++ i )
|
||||
now[i] = 0;
|
||||
sort( L, L+M , cmp3 );
|
||||
for ( int i = 0 ; i < M ; ++ i ) {
|
||||
L[i].hit = -1;
|
||||
for ( int j = 0 ; j < N ; ++ j ) {
|
||||
while ( cmp3( S[j].l[now[j]], L[i] ) ) ++ now[j];
|
||||
if ( l_cross_l( line( S[j].a[now[j]], S[j].b[now[j]] ), L[i] ) ) {
|
||||
q = crosspoint( L[i], S[j].a[now[j]], S[j].b[now[j]] );
|
||||
d2 = dist( q, point( L[i].x, L[i].y ) );
|
||||
if ( parameter( L[i], q ) < 0 ) continue;
|
||||
if ( L[i].hit == -1 ) {
|
||||
L[i].hit = j;
|
||||
L[i].d = d2;
|
||||
}else if ( L[i].d > d2 ) {
|
||||
L[i].hit = j;
|
||||
L[i].d = d2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
sort( L, L+M, cmp4 );
|
||||
for ( int i = 0 ; i < M ; ++ i )
|
||||
if ( L[i].hit != -1 )
|
||||
printf("HIT %d\n",L[i].hit);
|
||||
else printf("MISS\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,N,M;
|
||||
while ( scanf("%d",&T) != EOF )
|
||||
while ( T -- ) {
|
||||
scanf("%d",&N);
|
||||
for ( int i = 0 ; i < N ; ++ i ) {
|
||||
scanf("%d",&Q[i]);
|
||||
for ( int j = 0 ; j < Q[i] ; ++ j )
|
||||
scanf("%lf%lf",&P[i][j].x,&P[i][j].y);
|
||||
}
|
||||
scanf("%d",&M);
|
||||
for ( int i = 0 ; i < M ; ++ i ) {
|
||||
scanf("%lf%lf%lf%lf",&L[i].x,&L[i].y,&L[i].dx,&L[i].dy);
|
||||
L[i].id = i;
|
||||
if ( L[i].dx < 0 ) {
|
||||
L[i].dx *= -1;
|
||||
L[i].dy *= -1;
|
||||
L[i].sign = -1;
|
||||
}else L[i].sign = 1;
|
||||
}
|
||||
Graham( N, M );
|
||||
printf("*****\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
const int MAXN=100010;
|
||||
const double ZERO=1e-8;
|
||||
struct node
|
||||
{
|
||||
double x,y;
|
||||
}q[MAXN],p[MAXN];
|
||||
int N,M;
|
||||
void Init()
|
||||
{
|
||||
scanf("%d",&N);
|
||||
for (int i=0;i<N;i++)
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
}
|
||||
double det(node a,node b,node c)
|
||||
{
|
||||
return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);
|
||||
}
|
||||
double dot(node a,node b,node c)
|
||||
{
|
||||
return (b.x-a.x)*(c.x-a.x)+(b.y-a.y)*(c.y-a.y);
|
||||
}
|
||||
double det3(node a,node b,node c)
|
||||
{
|
||||
double s=det(a,b,c);
|
||||
if (fabs(s)<=ZERO) return 0;
|
||||
if (s<0) return -1; else return 1;
|
||||
}
|
||||
void Graham_scan(node *c,int &M0,int base,node q)
|
||||
{
|
||||
while (M0>base && det3(c[M0-2],c[M0-1],q)<=0) --M0;
|
||||
c[M0]=q;
|
||||
++M0;
|
||||
}
|
||||
bool cmp(node a,node b)
|
||||
{
|
||||
if ((a.y<b.y) || (a.y==b.y && a.x<b.x)) return 1; else return 0;
|
||||
}
|
||||
node c[MAXN];
|
||||
void Graham(node *p,int N0,node *q,int &M0)
|
||||
{
|
||||
for (int i=0;i<=N0;++i) q[i]=p[i];
|
||||
sort(q,q+N0,cmp);
|
||||
M0=0;
|
||||
for (int i=0;i<N0;++i)
|
||||
Graham_scan(c,M0,1,q[i]);
|
||||
int M1=M0;
|
||||
for (int i=N0-1;i>=0;--i)
|
||||
Graham_scan(c,M0,M1,q[i]);
|
||||
for (int i=0;i<M0;++i)
|
||||
q[i]=c[i];
|
||||
}
|
||||
int Find(node a,node b,node c)
|
||||
{
|
||||
double s=dot(b,a,c);
|
||||
if (s>ZERO) return 0; else return 1;
|
||||
}
|
||||
bool Cleck(node a,node b,node c)
|
||||
{
|
||||
return ((!Find(a,b,c))&&(!Find(a,c,b)));
|
||||
}
|
||||
void Solve()
|
||||
{
|
||||
node o,o1;
|
||||
double s=0,s1;
|
||||
o.x=o.y=0;
|
||||
for (int i=1;i<N-1;++i)
|
||||
{
|
||||
o1.x=(p[0].x+p[i].x+p[i+1].x)/3;
|
||||
o1.y=(p[0].y+p[i].y+p[i+1].y)/3;
|
||||
s1=det(p[0],p[i],p[i+1]);
|
||||
s+=s1;
|
||||
o.x+=o1.x*s1;
|
||||
o.y+=o1.y*s1;
|
||||
}
|
||||
o.x/=s;
|
||||
o.y/=s;
|
||||
Graham(p,N,q,M);
|
||||
q[M]=q[0];
|
||||
int ans=0;
|
||||
for (int i=0;i<M;++i)
|
||||
if (Cleck(o,q[i],q[i+1])) ++ans;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test;
|
||||
scanf("%d",&test);
|
||||
while (test--)
|
||||
{
|
||||
Init();
|
||||
Solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
#include <stdio.h>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define pb push_back
|
||||
const int maxn = 10000 + 10;
|
||||
const int maxm = 100000 + 10;
|
||||
struct Edge {
|
||||
int u, to, next, vis, id;
|
||||
}edge[maxm<<1];
|
||||
int head[maxn<<1], dfn[maxn<<1], low[maxn], st[maxm], iscut[maxn], subnet[maxn], bian[maxm];
|
||||
int E, time, top, btot;
|
||||
vector<int> belo[maxn];
|
||||
void newedge(int u, int to) {
|
||||
edge[E].u = u;
|
||||
edge[E].to = to;
|
||||
edge[E].next = head[u];
|
||||
edge[E].vis = 0;
|
||||
head[u] = E++;
|
||||
}
|
||||
void init(int n) {
|
||||
for(int i = 0;i <= n; i++) {
|
||||
head[i] = -1;
|
||||
dfn[i] = iscut[i] = subnet[i] = 0;
|
||||
belo[i].clear();
|
||||
}
|
||||
E = time = top = btot = 0;
|
||||
}
|
||||
void dfs(int u) {
|
||||
dfn[u] = low[u] = ++time;
|
||||
for(int i = head[u];i != -1;i = edge[i].next) {
|
||||
if(edge[i].vis) continue;
|
||||
edge[i].vis = edge[i^1].vis = 1;
|
||||
int to = edge[i].to;
|
||||
st[++top] = i;
|
||||
if(!dfn[to]) {
|
||||
dfs(to);
|
||||
low[u] = min(low[u], low[to]);
|
||||
if(low[to] >= dfn[u]) {
|
||||
subnet[u]++;
|
||||
iscut[u] = 1;
|
||||
btot++;
|
||||
do {
|
||||
int now = st[top--];
|
||||
belo[edge[now].u].pb(btot);
|
||||
belo[edge[now].to].pb(btot);
|
||||
bian[edge[now].id] = btot;
|
||||
to = edge[now].u;
|
||||
}while(to != u);
|
||||
}
|
||||
}
|
||||
else
|
||||
low[u] = min(low[u], low[to]);
|
||||
}
|
||||
}
|
||||
int B[maxn<<2], F[maxn<<2], d[maxn<<2][20], pos[maxn<<2], tot, dep[maxn<<1];
|
||||
bool treecut[maxn<<1];
|
||||
void RMQ_init(int n) {
|
||||
for(int i = 1;i <= n; i++) d[i][0] = B[i];
|
||||
for(int j = 1;(1<<j) <= n; j++)
|
||||
for(int i = 1;i + j - 1 <= n; i++)
|
||||
d[i][j] = min(d[i][j-1], d[i + (1<<(j-1))][j-1]);
|
||||
}
|
||||
int RMQ(int L, int R) {
|
||||
int k = 0;
|
||||
while((1<<(k+1)) <= R-L+1) k++;
|
||||
return min(d[L][k], d[R-(1<<k)+1][k] );
|
||||
}
|
||||
int lca(int a, int b) {
|
||||
if(pos[a] > pos[b]) swap(a, b);
|
||||
int ans = RMQ(pos[a], pos[b]);
|
||||
return F[ans];
|
||||
}
|
||||
void DFS(int u) {
|
||||
dfn[u] = ++time;
|
||||
B[++tot] = dfn[u];
|
||||
F[time] = u;
|
||||
pos[u] = tot;
|
||||
for(int i = head[u];i != -1;i = edge[i].next){
|
||||
int to = edge[i].to;
|
||||
if(!dfn[to]) {
|
||||
if(treecut[u])
|
||||
dep[to] = dep[u] + 1;
|
||||
else
|
||||
dep[to] = dep[u];
|
||||
DFS(to);
|
||||
B[++tot] = dfn[u];
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve(int n) {
|
||||
for(int i = 0;i <= n; i++) {
|
||||
dfn[i] = 0;
|
||||
}
|
||||
time = tot = 0;
|
||||
for(int i = 1;i <= n; i++) if(!dfn[i]) {
|
||||
dep[i] = 0;
|
||||
DFS(i);
|
||||
}
|
||||
RMQ_init(tot);
|
||||
int m, u, to;
|
||||
scanf("%d", &m);
|
||||
while(m--) {
|
||||
scanf("%d%d", &u, &to);
|
||||
u = bian[u]; to = bian[to];
|
||||
if(u < 0 || to < 0) {
|
||||
printf("0\n"); continue;
|
||||
}
|
||||
int LCA = lca(u, to);
|
||||
if(u == LCA)
|
||||
printf("%d\n", dep[to] - dep[u] - treecut[u]);
|
||||
else if(to == LCA)
|
||||
printf("%d\n", dep[u] - dep[to] - treecut[to]);
|
||||
else
|
||||
printf("%d\n", dep[u] + dep[to] - 2*dep[LCA] - treecut[LCA]);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int n, m, u, to;
|
||||
while(scanf("%d%d", &n, &m) != -1 && n){
|
||||
init(n);
|
||||
for(int i = 1;i <= m; i++) {
|
||||
scanf("%d%d", &u, &to);
|
||||
edge[E].id = i;
|
||||
newedge(u, to);
|
||||
edge[E].id = i;
|
||||
newedge(to, u);
|
||||
}
|
||||
for(int i = 1;i <= n;i ++) if(!dfn[i]) {
|
||||
dfs(i);
|
||||
subnet[i]--;
|
||||
if(subnet[i] <= 0) iscut[i] = 0;
|
||||
}
|
||||
int ditot = btot;
|
||||
for(int i = 1;i <= btot; i++) treecut[i] = 0;
|
||||
for(int i = 1;i <= btot+n; i++) head[i] = -1;
|
||||
E = 0;
|
||||
for(int i = 1;i <= n; i++) if(iscut[i]) {
|
||||
sort(belo[i].begin(), belo[i].end());
|
||||
ditot++;
|
||||
treecut[ditot] = 1;
|
||||
newedge(belo[i][0], ditot);
|
||||
newedge(ditot, belo[i][0]);
|
||||
for(int j = 1;j < belo[i].size(); j++) if(belo[i][j] != belo[i][j-1]) {
|
||||
newedge(belo[i][j], ditot);
|
||||
newedge(ditot, belo[i][j]);
|
||||
}
|
||||
}
|
||||
solve(ditot);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include "stdio.h"
|
||||
#include "string.h"
|
||||
#include "iostream"
|
||||
#include "algorithm"
|
||||
using namespace std;
|
||||
int inf=0x3f3f3f3f;
|
||||
int Fabs(int a)
|
||||
{
|
||||
if (a<0) return -a; else return a;
|
||||
}
|
||||
int Min(int a,int b)
|
||||
{
|
||||
if (a<b) return a;
|
||||
else return b;
|
||||
}
|
||||
struct node
|
||||
{
|
||||
int num;
|
||||
int x[210];
|
||||
}mark[210];
|
||||
int main()
|
||||
{
|
||||
int n,m,i,j,k,sum,ans;
|
||||
int dp[210][210];
|
||||
while (scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if (n==0 && m==0) break;
|
||||
memset(mark,0,sizeof(mark));
|
||||
for (i=1;i<=n*n;i++)
|
||||
{
|
||||
scanf("%d%d",&j,&k);
|
||||
mark[j].num++;
|
||||
mark[j].x[mark[j].num]=k;
|
||||
}
|
||||
for (i=1;i<=n;i++)
|
||||
sort(mark[i].x+1,mark[i].x+1+n);
|
||||
memset(dp,0,sizeof(dp));
|
||||
for (i=1;i<=n;i++)
|
||||
for (j=1;j<=m-n+1;j++)
|
||||
for (k=1;k<=n;k++)
|
||||
dp[i][j]+=Fabs(mark[i].x[k]-j-k+1);
|
||||
ans=inf;
|
||||
for (j=1;j<=m-n+1;j++)
|
||||
{
|
||||
sum=0;
|
||||
for (i=1;i<=n;i++)
|
||||
sum+=dp[i][j];
|
||||
ans=Min(sum,ans);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define inf 100000
|
||||
int n,m;
|
||||
int a[101][10010];
|
||||
int r[101][10010],c[101][10010];
|
||||
int que[10010][2],p,q;
|
||||
inline int max(int x,int y){return x<y?y:x;}
|
||||
inline int min(int x,int y){return x<y?x:y;}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if (n==0 && m==0) return 0;
|
||||
for (int i=1;i<=n;i++)
|
||||
for (int j=1;j<=m;j++)
|
||||
{
|
||||
scanf("%d",&a[i][j]);
|
||||
r[i][j]=c[i][j]=inf;
|
||||
}
|
||||
int ans=-1;
|
||||
while(1)
|
||||
{
|
||||
for (int i=1;i<=n;i++)
|
||||
for (int j=1;j<=m;j++)
|
||||
r[i][j]=c[i][j]=inf;
|
||||
for (int i=1;i<=n;i++)
|
||||
{
|
||||
p=1;q=0;
|
||||
for (int j=1;j<=m;j++)
|
||||
{
|
||||
while(p<=q && a[i][j]+j-1>=que[q][1]) q--;
|
||||
que[++q][0]=j;que[q][1]=a[i][j]+j-1;
|
||||
while(p<=q && que[q][1]<j) q--;
|
||||
if (p<=q)
|
||||
r[i][j]=j-que[q][0]+1;
|
||||
}
|
||||
p=1;q=0;
|
||||
for (int j=m;j>=1;j--)
|
||||
{
|
||||
while(p<=q && j-a[i][j]+1<=que[q][1]) q--;
|
||||
que[++q][0]=j;que[q][1]=j-a[i][j]+1;
|
||||
while(p<=q && que[q][1]>j) q--;
|
||||
if (p<=q)
|
||||
r[i][j]=min(r[i][j], que[q][0]-j+1);
|
||||
}
|
||||
}
|
||||
for (int j=1;j<=m;j++)
|
||||
{
|
||||
p=1;q=0;
|
||||
for (int i=1;i<=n;i++)
|
||||
{
|
||||
while(p<=q && a[i][j]+i-1>=que[q][1]) q--;
|
||||
que[++q][0]=i;que[q][1]=a[i][j]+i-1;
|
||||
while(p<=q && que[q][1]<i) q--;
|
||||
if (p<=q) c[i][j]=i-que[q][0]+1;
|
||||
}
|
||||
p=1;q=0;
|
||||
for (int i=n;i>=1;i--)
|
||||
{
|
||||
while(p<=q && i-a[i][j]+1<=que[q][1]) q--;
|
||||
que[++q][0]=i;que[q][1]=i-a[i][j]+1;
|
||||
while(p<=q && que[q][1]>i) q--;
|
||||
if (p<=q) c[i][j]=min(c[i][j], que[q][0]-i+1);
|
||||
}
|
||||
}
|
||||
int tmp=0;
|
||||
for (int i=1;i<=n;i++)
|
||||
for (int j=1;j<=m;j++)
|
||||
{
|
||||
tmp=max(tmp,max(c[i][j],r[i][j]));
|
||||
}
|
||||
if (tmp==ans) break;
|
||||
ans=tmp;
|
||||
for (int i=1;i<=n;i++)
|
||||
for (int j=1;j<=m;j++)
|
||||
{
|
||||
a[i][j]=(a[i][j]<tmp?0:a[i][j]);
|
||||
}
|
||||
}
|
||||
if (ans<inf) printf("%d\n",ans);
|
||||
else printf("NO ANSWER!\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define MAX 1005
|
||||
int cnt;
|
||||
struct node
|
||||
{
|
||||
int flag;
|
||||
int next[26],fail;
|
||||
} head[MAX];
|
||||
queue<int> q;
|
||||
double pt[30],dp[MAX][30];
|
||||
void build(char *s,int idx)
|
||||
{
|
||||
int len=strlen(s),k;
|
||||
for(int i=0; i<len; ++i)
|
||||
{
|
||||
k=s[i]-'a';
|
||||
if(head[idx].next[k]==0)
|
||||
head[idx].next[k]=(cnt++);
|
||||
idx=head[idx].next[k];
|
||||
}
|
||||
head[idx].flag=1;
|
||||
}
|
||||
void build_fail(int idx)
|
||||
{
|
||||
int now;
|
||||
queue<int> q;
|
||||
head[idx].fail=0;
|
||||
q.push(idx);
|
||||
for(; !q.empty();)
|
||||
{
|
||||
now=q.front();
|
||||
q.pop();
|
||||
for(int i=0; i<26; ++i)
|
||||
if(head[now].next[i])
|
||||
{
|
||||
if(now==0) head[head[now].next[i]].fail=0;
|
||||
else head[head[now].next[i]].fail=head[head[now].fail].next[i];
|
||||
q.push(head[now].next[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(now==0) head[now].next[i]=0;
|
||||
else head[now].next[i]=head[head[now].fail].next[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,v;
|
||||
double t;
|
||||
char s[1005];
|
||||
for(; scanf("%d%d",&n,&m);)
|
||||
{
|
||||
if(n+m==0) break;
|
||||
memset(pt,0,sizeof(pt));
|
||||
memset(dp,0,sizeof(dp));
|
||||
memset(head,0,sizeof(head));
|
||||
cnt=1;
|
||||
for(int i=1; i<=n; ++i)
|
||||
{
|
||||
scanf("%s%lf",s,&t);
|
||||
pt[s[0]-'a']=t;
|
||||
}
|
||||
scanf("%s",s);
|
||||
build(s,0);
|
||||
build_fail(0);
|
||||
dp[0][0]=1;
|
||||
for(int i=0; i<m; ++i)
|
||||
for(int j=0; j<cnt-1; ++j)
|
||||
if(i>=j)
|
||||
{
|
||||
for(int k=0; k<26; ++k)
|
||||
{
|
||||
v=head[j].next[k];
|
||||
dp[i+1][v]+=(dp[i][j]*pt[k]);
|
||||
}
|
||||
}
|
||||
double ans=0;
|
||||
for(int i=0; i<=m; i++)
|
||||
ans+=dp[i][cnt-1];
|
||||
printf("%.2f%%\n",ans*100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <memory.h>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <utility>
|
||||
#define MAX(a , b) ((a) > (b) ? (a) : (b))
|
||||
#define sqr(x) ((x) * (x))
|
||||
#define mp make_pair
|
||||
typedef long long ll;
|
||||
using namespace std;
|
||||
const int maxn = 12;
|
||||
const int maxm = 400000;
|
||||
const int kr = 1;
|
||||
const int prime = 999997;
|
||||
struct ddd
|
||||
{
|
||||
int x,y;
|
||||
int step;
|
||||
};
|
||||
struct node
|
||||
{
|
||||
int x,y;
|
||||
int next;
|
||||
}edge[maxm];
|
||||
int head[prime],vec[maxn][2];
|
||||
queue <ddd> Q;
|
||||
int sx,sy,tx,ty,a,b,c,d,n,idx;
|
||||
void init()
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
idx = 0;
|
||||
return;
|
||||
}
|
||||
int ha(int x,int y)
|
||||
{
|
||||
return (((x << 15) ^ y) % prime + prime) % prime;
|
||||
}
|
||||
bool addedge(int key,int x,int y)
|
||||
{
|
||||
for(int i=head[key];i != -1;i=edge[i].next)
|
||||
{
|
||||
if(edge[i].x == x && edge[i].y == y) return false;
|
||||
}
|
||||
edge[idx].x = x;
|
||||
edge[idx].y = y;
|
||||
edge[idx].next = head[key];
|
||||
head[key] = idx++;
|
||||
return true;
|
||||
}
|
||||
void read()
|
||||
{
|
||||
d = 0;
|
||||
scanf("%d %d %d %d",&sx,&sy,&tx,&ty);
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d %d",&vec[i][0],&vec[i][1]);
|
||||
d = MAX(d , sqr(vec[i][0]) + sqr(vec[i][1]));
|
||||
}
|
||||
a = ty - sy;
|
||||
b = sx - tx;
|
||||
c = sy * tx - sx * ty;
|
||||
return;
|
||||
}
|
||||
bool IsValid(int x,int y)
|
||||
{
|
||||
if(sqr(x - sx) + sqr(y - sy) <= sqr(kr) * d) return true;
|
||||
if(sqr(x - tx) + sqr(y - ty) <= sqr(kr) * d) return true;
|
||||
if((tx - sx) * (x - sx) + (ty - sy) * (y - sy) < 0) return false;
|
||||
if((sx - tx) * (x - tx) + (sy - ty) * (y - ty) < 0) return false;
|
||||
if(sqr(ll(a) * x + b * y + c) <= ll(d) * (sqr(a) + sqr(b))) return true;
|
||||
return false;
|
||||
}
|
||||
void bfs()
|
||||
{
|
||||
while(!Q.empty()) Q.pop();
|
||||
ddd cur,tmp;
|
||||
tmp.x = sx;
|
||||
tmp.y = sy;
|
||||
tmp.step = 0;
|
||||
Q.push(tmp);
|
||||
addedge(ha(sx , sy) , sx , sy);
|
||||
while(!Q.empty())
|
||||
{
|
||||
cur = Q.front();
|
||||
Q.pop();
|
||||
if(cur.x == tx && cur.y == ty)
|
||||
{
|
||||
printf("%d\n",cur.step);
|
||||
return;
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int xx = cur.x + vec[i][0];
|
||||
int yy = cur.y + vec[i][1];
|
||||
if(IsValid(xx , yy) && addedge(ha(xx , yy) , xx , yy))
|
||||
{
|
||||
tmp.x = xx;
|
||||
tmp.y = yy;
|
||||
tmp.step = cur.step + 1;
|
||||
Q.push(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
puts("IMPOSSIBLE");
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas;
|
||||
scanf("%d",&cas);
|
||||
while(cas--)
|
||||
{
|
||||
init();
|
||||
read();
|
||||
bfs();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN=400;
|
||||
const int INF=0x7fffffff;
|
||||
int N,M,S;
|
||||
int a[MAXN][MAXN],dis[MAXN];
|
||||
bool visit[MAXN],d[MAXN];
|
||||
int StoerWagner(int N)
|
||||
{
|
||||
int p=N,ans=INF,Max,t,s,k,i;
|
||||
memset(d,0,sizeof(d));
|
||||
while (--p>0)
|
||||
{
|
||||
memset(visit,0,sizeof(visit));
|
||||
memset(dis,0,sizeof(dis));
|
||||
i=1;
|
||||
while (d[i]) i++;
|
||||
visit[i]=1;
|
||||
for (int j=1;j<=N;j++)
|
||||
if (!d[j] && !visit[j])
|
||||
dis[j]=a[i][j];
|
||||
t=s=i;
|
||||
for (;i<=N;i++)
|
||||
{
|
||||
Max=0;
|
||||
for (int j=1;j<=N;j++)
|
||||
if (!d[j] && !visit[j] && Max<dis[j])
|
||||
Max=dis[k=j];
|
||||
if (!Max) break;
|
||||
visit[k]=1;
|
||||
for (int j=1;j<=N;j++)
|
||||
if (!d[j] && !visit[j])
|
||||
dis[j]+=a[k][j];
|
||||
s=t;
|
||||
t=k;
|
||||
}
|
||||
if (ans>dis[t]) ans=dis[t];
|
||||
d[t]=1;
|
||||
for (int j=1;j<=N;j++)
|
||||
if (!d[j])
|
||||
{
|
||||
a[s][j]+=a[t][j];
|
||||
a[j][s]+=a[j][t];
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
scanf("%d%d%d",&N,&M,&S);
|
||||
if (!N && !M && !S) break;
|
||||
memset(a,0,sizeof(a));
|
||||
for (int i=1;i<=M;i++)
|
||||
{
|
||||
int x,y,d;
|
||||
scanf("%d%d%d",&x,&y,&d);
|
||||
a[x][y]+=d;
|
||||
a[y][x]+=d;
|
||||
}
|
||||
printf("%d\n",StoerWagner(N));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
typedef struct p1node
|
||||
{
|
||||
double a,b,c,d;
|
||||
}plane;
|
||||
plane Pl;
|
||||
typedef struct p2node
|
||||
{
|
||||
double x,y,z;
|
||||
}point;
|
||||
point temp;
|
||||
point P[ 105 ];
|
||||
point S[ 105 ];
|
||||
int shadow( plane p, point s, int n )
|
||||
{
|
||||
double D = p.a*s.x+p.b*s.y+p.c*s.z;
|
||||
if ( D-p.d < 0 ) {
|
||||
p.a *= -1;p.b *= -1;p.c *= -1;
|
||||
p.d *= -1;
|
||||
D *= -1;
|
||||
}
|
||||
int count = 0;
|
||||
for ( int i = 0 ; i < n ; ++ i ) {
|
||||
double det = p.a*P[i].x+p.b*P[i].y+p.c*P[i].z-D;
|
||||
if ( det < 0 ) count ++;
|
||||
}
|
||||
if ( count == 0 ) return 0;
|
||||
if ( count != n ) return n+1;
|
||||
for ( int i = 0 ; i < n ; ++ i ) {
|
||||
double dx = P[i].x - s.x;
|
||||
double dy = P[i].y - s.y;
|
||||
double dz = P[i].z - s.z;
|
||||
double t = (p.d-p.a*s.x-p.b*s.y-p.c*s.z)/(p.a*dx+p.b*dy+p.c*dz);
|
||||
P[i].x = s.x + t*dx;
|
||||
P[i].y = s.y + t*dy;
|
||||
P[i].z = s.z + t*dz;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
void change( plane p, int n )
|
||||
{
|
||||
if ( p.a*p.a + p.b*p.b == 0 ) return;
|
||||
for ( int i = 0 ; i < n ; ++ i ) {
|
||||
double cosC = p.b/sqrt(p.a*p.a+p.b*p.b);
|
||||
double sinC = p.a/sqrt(p.a*p.a+p.b*p.b);
|
||||
temp.x = P[i].x*cosC-P[i].y*sinC;
|
||||
temp.y = P[i].x*sinC+P[i].y*cosC;
|
||||
temp.z = P[i].z;
|
||||
P[i] = temp;
|
||||
double cosA = p.c/sqrt(p.a*p.a+p.b*p.b+p.c*p.c);
|
||||
double sinA = sqrt(p.a*p.a+p.b*p.b)/sqrt(p.a*p.a+p.b*p.b+p.c*p.c);
|
||||
temp.x = P[i].x;
|
||||
temp.y = P[i].y*cosA-P[i].z*sinA;
|
||||
temp.z = P[i].y*sinA+P[i].z*cosA;
|
||||
P[i] = temp;
|
||||
}
|
||||
}
|
||||
double crossproduct( point a, point b, point c )
|
||||
{
|
||||
return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);
|
||||
}
|
||||
bool cmp1( point a, point b )
|
||||
{
|
||||
if ( a.x == b.x )
|
||||
return a.y < b.y;
|
||||
return a.x < b.x;
|
||||
}
|
||||
bool cmp2( point a, point b )
|
||||
{
|
||||
return crossproduct( P[0], a, b )>0;
|
||||
}
|
||||
void Graham( int n )
|
||||
{
|
||||
sort( P+0, P+n, cmp1 );
|
||||
sort( P+1, P+n, cmp2 );
|
||||
int top = -1;
|
||||
if ( n > 0 ) S[++ top] = P[0];
|
||||
if ( n > 1 ) S[++ top] = P[1];
|
||||
if ( n > 2 ) {
|
||||
for ( int i = 2 ; i < n ; ++ i ) {
|
||||
while ( crossproduct( S[top-1], S[top], P[i] ) < 0 ) -- top;
|
||||
S[++ top] = P[i];
|
||||
}
|
||||
}
|
||||
double area = 0.0;
|
||||
for ( int i = 2 ; i <= top ; ++ i )
|
||||
area += crossproduct( S[0], S[i-1], S[i] );
|
||||
printf("%.2lf\n",area*0.5);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while ( cin >> Pl.a >> Pl.b >> Pl.c >> Pl.d ) {
|
||||
if ( Pl.a == 0 && Pl.b == 0 && Pl.c == 0 ) break;
|
||||
cin >> n;
|
||||
for ( int i = 0 ; i <= n ; ++ i )
|
||||
cin >> P[i].x >> P[i].y >> P[i].z;
|
||||
int s_count = shadow( Pl, P[n], n );
|
||||
if ( !s_ )
|
||||
cout << "0.00" << endl;
|
||||
else if ( s_count > n )
|
||||
cout << "Infi" << endl;
|
||||
else {
|
||||
change( Pl, s_ );
|
||||
Graham( s_ );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<cstdio>
|
||||
#include<sstream>
|
||||
#include<cstdlib>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<stack>
|
||||
#include<list>
|
||||
#include<queue>
|
||||
#include<ctime>
|
||||
#include<bitset>
|
||||
#define eps 1e-6
|
||||
#define INF 0x3f3f3f3f
|
||||
#define PI acos(-1.0)
|
||||
#define ll __int64
|
||||
#define LL long long
|
||||
#define lson l,m,(rt<<1)
|
||||
#define rson m+1,r,(rt<<1)|1
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
#define Maxn 55
|
||||
#define m 30
|
||||
#define M 1000000003
|
||||
int sa[Maxn],n,k,num;
|
||||
ll sum[m+5];
|
||||
ll dp[Maxn][Maxn],bina[m+5];
|
||||
void init()
|
||||
{
|
||||
bina[0]=1;
|
||||
for(int i=1;i<=m;i++)
|
||||
bina[i]=bina[i-1]*2;
|
||||
}
|
||||
int Sum1(ll tmp)
|
||||
{
|
||||
int res=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
if(sa[i]&tmp)
|
||||
res++;
|
||||
return res;
|
||||
}
|
||||
ll left(int a,int b)
|
||||
{
|
||||
if(!b)
|
||||
return 1;
|
||||
else
|
||||
return (sa[a]&(bina[b]-1))+1;
|
||||
}
|
||||
ll Cal(int pos,int num,int s,int need)
|
||||
{
|
||||
if(s==0)
|
||||
{
|
||||
if((num&1)!=need)
|
||||
return 0;
|
||||
else
|
||||
{
|
||||
if(pos==0)
|
||||
return 1;
|
||||
else
|
||||
return sum[pos-1];
|
||||
}
|
||||
}
|
||||
dp[0][0]=1;
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=0;j<num;j++)
|
||||
{
|
||||
dp[i][j]=0;
|
||||
if(bina[pos]&sa[i])
|
||||
{
|
||||
if(i==s)
|
||||
dp[i][j]=dp[i-1][j]%M;
|
||||
else if(i>s)
|
||||
dp[i][j]=(dp[i-1][j]*bina[pos])%M;
|
||||
}
|
||||
else
|
||||
dp[i][j]=(dp[i-1][j]*left(i,pos))%M;
|
||||
if(bina[pos]&sa[i])
|
||||
{
|
||||
if(i!=s)
|
||||
{
|
||||
if(j)
|
||||
dp[i][j]=(dp[i][j]+dp[i-1][j-1]*left(i,pos))%M;
|
||||
}
|
||||
}
|
||||
}
|
||||
ll res=0;
|
||||
for(int i=0;i<num;i++)
|
||||
if((i&1)==need)
|
||||
res=(res+dp[n][i])%M;
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
while(~scanf("%d%d",&n,&k))
|
||||
{
|
||||
if(n+k==0)
|
||||
break;
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&sa[i]);
|
||||
memset(sum,0,sizeof(sum));
|
||||
for(int pos=0;pos<=m;pos++)
|
||||
{
|
||||
ll tmp=bina[pos];
|
||||
num=Sum1(tmp);
|
||||
int need;
|
||||
if(k&tmp)
|
||||
need=1;
|
||||
else
|
||||
need=0;
|
||||
for(int i=0;i<=n;i++)
|
||||
if(!i||(tmp&sa[i]))
|
||||
sum[pos]=(sum[pos]+Cal(pos,num,i,need))%M;
|
||||
}
|
||||
printf("%I64d\n",sum[m]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<utility>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
const int M=15;
|
||||
const double inf=1e250;
|
||||
struct point
|
||||
{
|
||||
double x,y;
|
||||
bool operator < (const point a)const
|
||||
{
|
||||
if(y==a.y)
|
||||
return x<a.x;
|
||||
return y<a.y;
|
||||
}
|
||||
}p[M],stac[M];
|
||||
int n,top;
|
||||
double dis(point a,point b)
|
||||
{
|
||||
return sqrt((b.x-a.x)*(b.x-a.x)+(b.y-a.y)*(b.y-a.y));
|
||||
}
|
||||
double xmult(double x1,double y1,double x2,double y2)
|
||||
{
|
||||
return x1*y2-x2*y1;
|
||||
}
|
||||
double cross(point p0,point p1,point p2)
|
||||
{
|
||||
double x1=p1.x-p0.x,y1=p1.y-p0.y;
|
||||
double x2=p2.x-p0.x,y2=p2.y-p0.y;
|
||||
return xmult(x1,y1,x2,y2);
|
||||
}
|
||||
void covex_hull()
|
||||
{
|
||||
sort(p,p+n);
|
||||
stac[0]=p[0];
|
||||
stac[1]=p[1];
|
||||
top=1;
|
||||
for(int i=2;i<n;i++)
|
||||
{
|
||||
while(top>0 && cross(stac[top],p[i],stac[top-1])<=0)
|
||||
top--;
|
||||
stac[++top]=p[i];
|
||||
}
|
||||
int temp=top;
|
||||
for(int i=n-2;i>=0;i--)
|
||||
{
|
||||
while(top>temp && cross(stac[top],p[i],stac[top-1])<=0)
|
||||
top--;
|
||||
stac[++top]=p[i];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&p[0].x,&p[0].y,&p[1].x,&p[1].y,&p[2].x,&p[2].y,&p[3].x,&p[3].y)==8)
|
||||
{
|
||||
if(p[0].x==-1 && p[0].y==-1 && p[1].x==-1 && p[1].y==-1 && p[2].x==-1 && p[2].y==-1 && p[3].x==-1 && p[3].y==-1)
|
||||
break;
|
||||
n=4;
|
||||
covex_hull();
|
||||
double ans;
|
||||
if(top==4)
|
||||
{
|
||||
ans=dis(stac[0],stac[2])+dis(stac[1],stac[3]);
|
||||
}
|
||||
else
|
||||
{
|
||||
ans=inf;
|
||||
ans=min(ans,dis(p[0],p[1])+dis(p[0],p[2])+dis(p[0],p[3]));
|
||||
ans=min(ans,dis(p[1],p[0])+dis(p[1],p[2])+dis(p[1],p[3]));
|
||||
ans=min(ans,dis(p[2],p[1])+dis(p[2],p[0])+dis(p[2],p[3]));
|
||||
ans=min(ans,dis(p[3],p[1])+dis(p[3],p[2])+dis(p[3],p[0]));
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
const int MAXN = 5200005;
|
||||
const int MAX_NODE = 3000005;
|
||||
const int SIGMA_SIZE = 26;
|
||||
char str[MAXN];
|
||||
char buf[MAXN];
|
||||
struct node{
|
||||
node* fail;
|
||||
node* next[SIGMA_SIZE];
|
||||
bool isword;
|
||||
int id;
|
||||
void init(){
|
||||
id=0;
|
||||
isword=false;
|
||||
memset(next, 0, sizeof(next));
|
||||
}
|
||||
};
|
||||
class AC_Automation{
|
||||
public:
|
||||
void init();
|
||||
void insert(char*,int);
|
||||
void getFail();
|
||||
int find(char*);
|
||||
private:
|
||||
node* new_node();
|
||||
int ID(char ch){return ch-'A';}
|
||||
private:
|
||||
node Heap[MAX_NODE];
|
||||
node* root;
|
||||
int size;
|
||||
};
|
||||
node* AC_Automation::new_node(){
|
||||
Heap[size].init();
|
||||
return &Heap[size++];
|
||||
}
|
||||
void AC_Automation::init(){
|
||||
size=0;
|
||||
root=new_node();
|
||||
}
|
||||
void AC_Automation::insert(char* str,int id){
|
||||
node* p=root;
|
||||
for( ; *str; ++str){
|
||||
int ch=ID(*str);
|
||||
if(p->next[ch] == NULL)
|
||||
p->next[ch] = new_node();
|
||||
p = p->next[ch];
|
||||
}
|
||||
p->isword=true;
|
||||
p->id=id;
|
||||
}
|
||||
void AC_Automation::getFail(){
|
||||
queue<node*>Q;
|
||||
Q.push(root);
|
||||
while(!Q.empty()){
|
||||
node* tmp=Q.front(); Q.pop();
|
||||
for(int i=0; i<SIGMA_SIZE; ++i){
|
||||
node*& now = tmp->next[i];
|
||||
if(now != NULL){
|
||||
Q.push(now);
|
||||
if(tmp==root) now->fail=root;
|
||||
else{
|
||||
node* p=tmp->fail;
|
||||
while(p != NULL){
|
||||
if(p->next[i] != NULL){
|
||||
now->fail = p->next[i];
|
||||
break;
|
||||
}
|
||||
p = p->fail;
|
||||
}
|
||||
if(p==NULL) now->fail=root;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(tmp==root) now = root;
|
||||
else now=tmp->fail->next[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int AC_Automation::find(char* str){
|
||||
node* p=root;
|
||||
int cnt=0;
|
||||
for( ; *str; ++str){
|
||||
int ch=ID(*str);
|
||||
p = p->next[ch];
|
||||
if(p==NULL) p=root;
|
||||
node* tmp=p;
|
||||
while(tmp!=root && tmp->isword){
|
||||
++cnt;
|
||||
tmp->isword=false;
|
||||
tmp = tmp->fail;
|
||||
}
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
inline void rev(char* str, int len){
|
||||
char ch;
|
||||
for(int i=0, k=len-1; i<len/2; ++i,--k){
|
||||
ch=str[i]; str[i]=str[k]; str[k]=ch;
|
||||
}
|
||||
}
|
||||
inline void change(char* str,char* now){
|
||||
memset(now, 0, sizeof(now));
|
||||
int len=strlen(str);
|
||||
int i;
|
||||
for(i=0; i<len; ++i){
|
||||
if(str[i]=='['){
|
||||
++i;
|
||||
int num=0;
|
||||
while(str[i]>='0' && str[i]<='9'){
|
||||
num = num*10 + str[i] - '0';
|
||||
++i;
|
||||
}
|
||||
while(num--){
|
||||
*now = str[i];
|
||||
++now;
|
||||
}
|
||||
++i;
|
||||
}
|
||||
else{
|
||||
*now=str[i];
|
||||
++now;
|
||||
}
|
||||
}
|
||||
}
|
||||
AC_Automation ac;
|
||||
int main(){
|
||||
int n,nCase;
|
||||
char pat[1005];
|
||||
scanf("%d",&nCase);
|
||||
while(nCase--){
|
||||
ac.init();
|
||||
scanf("%d%*c",&n);
|
||||
for(int i=1; i<=n; ++i){
|
||||
gets(pat);
|
||||
ac.insert(pat, i);
|
||||
}
|
||||
ac.getFail();
|
||||
memset(buf, 0, sizeof(buf));
|
||||
memset(str, 0, sizeof(str));
|
||||
gets(buf);
|
||||
change(buf,str);
|
||||
int ans=ac.find(str);
|
||||
rev(str,strlen(str));
|
||||
printf("%d\n", ans+ac.find(str));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#define N 10005
|
||||
using namespace std;
|
||||
int n,m,num,adj[N],q[N];
|
||||
bool f[N];
|
||||
double low[N],p[N],w[N];
|
||||
struct edge
|
||||
{
|
||||
int v,pre;
|
||||
double w;
|
||||
edge(){}
|
||||
edge(int vv,double ww,int p){v=vv;w=ww;pre=p;}
|
||||
}e[N*5];
|
||||
void insert(int u,int v,double w)
|
||||
{
|
||||
e[num]=edge(v,w,adj[u]);
|
||||
adj[u]=num++;
|
||||
}
|
||||
void spfa(int x)
|
||||
{
|
||||
int i,v,head=0,tail=0;
|
||||
memset(f,0,sizeof(f));
|
||||
memset(low,-0x3f,sizeof(low));
|
||||
low[x]=0;
|
||||
q[++tail]=x;
|
||||
while(head!=tail)
|
||||
{
|
||||
x=q[head=(head+1)%N];
|
||||
f[x]=0;
|
||||
for(i=adj[x];~i;i=e[i].pre)
|
||||
if(low[v=e[i].v]<low[x]+e[i].w)
|
||||
{
|
||||
low[v]=low[x]+e[i].w;
|
||||
if(!f[v])
|
||||
{
|
||||
f[v]=1;
|
||||
q[tail=(tail+1)%N]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
int i,k,a,b;
|
||||
double t,ans=0;
|
||||
num=0;
|
||||
memset(adj,-1,sizeof(adj));
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%lf%lf",p+i,w+i);
|
||||
scanf("%d",&m);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d",&k);
|
||||
scanf("%d",&a);
|
||||
for(i=1;i<k;i++)
|
||||
{
|
||||
scanf("%lf%d",&t,&b);
|
||||
insert(b,a,log(t));
|
||||
a=b;
|
||||
}
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
insert(0,i,log(p[i]));
|
||||
spfa(0);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(p[i]<exp(low[i]))
|
||||
p[i]=exp(low[i]);
|
||||
ans+=p[i]*w[i];
|
||||
}
|
||||
printf("%.2f\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#define inf 0x3fffffff
|
||||
#define N 1100
|
||||
struct node {
|
||||
int l,r;
|
||||
}f[N];
|
||||
int ff[N];
|
||||
double d;
|
||||
int Min(int aa,int bb) {
|
||||
return aa>bb?bb:aa;
|
||||
}
|
||||
int Max(int aa,int bb) {
|
||||
return aa>bb?aa:bb;
|
||||
}
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return (*(struct node *)a).r-(*(struct node *)b).r;
|
||||
}
|
||||
int main() {
|
||||
int n,i,j;
|
||||
int minn,maxx,tot,kk,k,ss,endd;
|
||||
while(scanf("%d",&n),n) {
|
||||
minn=inf;
|
||||
maxx=-1;
|
||||
for(i=0;i<n;i++) {
|
||||
scanf("%d%d",&f[i].l,&f[i].r);
|
||||
minn=Min(f[i].l,minn);
|
||||
maxx=Max(f[i].r,maxx);
|
||||
}
|
||||
qsort(f,n,sizeof(f[0]),cmp);
|
||||
endd=0;
|
||||
for(i=minn;i<=maxx;i++) {
|
||||
tot=0;
|
||||
memset(ff,0,sizeof(ff));
|
||||
for(j=0;j<n;j++) {
|
||||
kk=(f[j].l-i)/5;
|
||||
if(kk*5+i!=f[j].l)
|
||||
kk=kk*5+i+5;
|
||||
else
|
||||
kk=f[j].l;
|
||||
k=(f[j].r-i)/5;
|
||||
if(k*5+i==f[j].r)
|
||||
k=f[j].r-5;
|
||||
else
|
||||
k=5*k+i;
|
||||
k=Min(k,kk);
|
||||
for(ss=k;ss<f[j].r;ss+=5) {
|
||||
if(ff[ss]==0&&ss>=f[j].l&&ss<f[j].r) {
|
||||
tot++;
|
||||
ff[ss]=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(endd<tot)
|
||||
endd=tot;
|
||||
}
|
||||
printf("%d\n",endd);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define inf 1073741823
|
||||
#define N 105
|
||||
#define M 5005
|
||||
int t[N][M];
|
||||
int f[N][M];
|
||||
int dp[N][M];
|
||||
int summ[M<<2],add[M<<2];
|
||||
inline int min(int a,int b)
|
||||
{
|
||||
return a<b?a:b;
|
||||
}
|
||||
void push_down(int idx)
|
||||
{
|
||||
if(add[idx]!=inf)
|
||||
{
|
||||
add[idx<<1]=min(add[idx<<1],add[idx]);
|
||||
add[idx<<1|1]=min(add[idx<<1|1],add[idx]);
|
||||
summ[idx<<1]=min(summ[idx<<1],add[idx<<1]);
|
||||
summ[idx<<1|1]=min(summ[idx<<1|1],add[idx<<1|1]);
|
||||
add[idx]=inf;
|
||||
}
|
||||
}
|
||||
void build(int l,int r,int idx)
|
||||
{
|
||||
summ[idx]=inf;
|
||||
add[idx]=inf;
|
||||
if(l==r) return;
|
||||
int mid=(l+r)>>1;
|
||||
build(l,mid,idx<<1);
|
||||
build(mid+1,r,idx<<1|1);
|
||||
}
|
||||
void update(int a,int b,int w,int l,int r,int idx)
|
||||
{
|
||||
if(a<=l&&r<=b)
|
||||
{
|
||||
add[idx]=min(w,add[idx]);
|
||||
summ[idx]=min(add[idx],summ[idx]);
|
||||
return;
|
||||
}
|
||||
int mid=(l+r)>>1;
|
||||
push_down(idx);
|
||||
if(a<=mid) update(a,b,w,l,mid,idx<<1);
|
||||
if(mid<b) update(a,b,w,mid+1,r,idx<<1|1);
|
||||
summ[idx]=min(summ[idx<<1],summ[idx<<1|1]);
|
||||
}
|
||||
int query(int a,int b,int l,int r,int idx)
|
||||
{
|
||||
if(a<=l&&r<=b)
|
||||
return summ[idx];
|
||||
int mid=(l+r)>>1;
|
||||
push_down(idx);
|
||||
int res=inf;
|
||||
if(a<=mid) res=min(res,query(a,b,l,mid,idx<<1));
|
||||
if(mid<b) res=min(res,query(a,b,mid+1,r,idx<<1|1));
|
||||
return res;
|
||||
}
|
||||
inline void scan(int &n)
|
||||
{
|
||||
char cc ;
|
||||
for(;cc=getchar(),cc<'0'||cc>'9';);
|
||||
n=cc-'0';
|
||||
for(;cc=getchar(),cc>='0'&&cc<='9';)
|
||||
n=n*10+cc-'0';
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
for(;scanf("%d%d",&n,&m)&&(n!=0||m!=0);)
|
||||
{
|
||||
for(int i=1;i<=n;++i)
|
||||
for(int j=1;j<=m;++j)
|
||||
scan(t[i][j]);
|
||||
for(int i=1;i<=n;++i)
|
||||
for(int j=1;j<=m;++j)
|
||||
scan(f[i][j]);
|
||||
for(int i=1;i<=m;++i)
|
||||
dp[1][i]=t[1][i];
|
||||
for(int i=2;i<=n;++i)
|
||||
{
|
||||
build(1,m,1);
|
||||
for(int j=1;j<=m;++j)
|
||||
update(j-f[i-1][j],j+f[i-1][j],dp[i-1][j],1,m,1);
|
||||
for(int j=1;j<=m;++j)
|
||||
dp[i][j]=query(j-f[i][j],j+f[i][j],1,m,1)+t[i][j];
|
||||
}
|
||||
int ans=inf;
|
||||
for(int i=1;i<=m;++i)
|
||||
ans=min(ans,dp[n][i]);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
int tot, sct, lena, lenb, lenc;
|
||||
char s1[10], s2[10], s3[10], save[10], save0[10], dig[10];
|
||||
char ss1[10], ss2[10], ss3[10], soso[10];
|
||||
void solve(int cct)
|
||||
{
|
||||
if(cct >= sct)
|
||||
{
|
||||
int aa, bb, cc;
|
||||
for(int i = 0; i < sct; i++)
|
||||
{
|
||||
for(int j = 0; j < lena; j++)
|
||||
if(ss1[j] == save[i])
|
||||
s1[j] = dig[i];
|
||||
for(int j = 0; j < lenb; j++)
|
||||
if(ss2[j] == save[i])
|
||||
s2[j] = dig[i];
|
||||
for(int j = 0; j < lenc; j++)
|
||||
if(ss3[j] == save[i])
|
||||
s3[j] = dig[i];
|
||||
sscanf(s1, "%d", &aa);
|
||||
sscanf(s2, "%d", &bb);
|
||||
sscanf(s3, "%d", &cc);
|
||||
}
|
||||
if(aa * bb == cc)
|
||||
++tot;
|
||||
if(aa - bb == cc)
|
||||
++tot;
|
||||
if(aa + bb == cc)
|
||||
++tot;
|
||||
if(bb != 0 && aa / bb == cc && aa % bb == 0)
|
||||
++tot;
|
||||
return ;
|
||||
}
|
||||
int flag;
|
||||
if(strlen(save0) && strchr(save0, save[cct]) != NULL)
|
||||
flag = 1;
|
||||
else
|
||||
flag = 0;
|
||||
for(int j = flag; j < 10; j++)
|
||||
if(strchr(soso, ('0' + j)) == NULL)
|
||||
{
|
||||
soso[cct] = '0' + j;
|
||||
dig[cct] = '0' + j;
|
||||
solve(cct + 1);
|
||||
soso[cct] = '\0';
|
||||
}
|
||||
return ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
int zct = 0;
|
||||
tot = sct = 0;
|
||||
memset(s1, 0, sizeof(s1));
|
||||
memset(s2, 0, sizeof(s2));
|
||||
memset(s3, 0, sizeof(s3));
|
||||
memset(save, 0, sizeof(save));
|
||||
memset(save0, 0, sizeof(save0));
|
||||
memset(soso, 0, sizeof(soso));
|
||||
scanf("%s%s%s", ss1, ss2, ss3);
|
||||
strcpy(s1, ss1);
|
||||
strcpy(s2, ss2);
|
||||
strcpy(s3, ss3);
|
||||
lena = strlen(s1), lenb = strlen(s2), lenc = strlen(s3);
|
||||
if(strchr(save0, s1[0]) == NULL && lena > 1)
|
||||
save0[zct++] = s1[0];
|
||||
if(strchr(save0, s2[0]) == NULL && lenb > 1)
|
||||
save0[zct++] = s2[0];
|
||||
if(strchr(save0, s3[0]) == NULL && lenc > 1)
|
||||
save0[zct++] = s3[0];
|
||||
for(int i = 0; i < lena; i++)
|
||||
if(strchr(save, s1[i]) == NULL)
|
||||
save[sct++] = s1[i];
|
||||
for(int i = 0; i < lenb; i++)
|
||||
if(strchr(save, s2[i]) == NULL)
|
||||
save[sct++] = s2[i];
|
||||
for(int i = 0; i < lenc; i++)
|
||||
if(strchr(save, s3[i]) == NULL)
|
||||
save[sct++] = s3[i];
|
||||
solve(0);
|
||||
printf("%d\n", tot);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue