Kiritow/OJ-Problems-Source
1
0
Fork 0
mirror of https://github.com/Kiritow/OJ-Problems-Source.git synced 2024-03-22 13:11:29 +08:00
Code Issues Projects Releases Wiki Activity

Powered By HC TECH : AutoACer Engine

Browse Source 
3900-3999
This commit is contained in:
KiritoTRw 2016-09-04 14:19:03 +08:00 committed by GitHub
parent e7ac37406c
commit 9da6cdd5bd
80 changed files with 8038 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
HDOJ/3900_autoAC.cpp Normal file
View File

@ -0,0 +1,115 @@
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define ll long long
struct data
{
int t,l,c;
}B[3545];
int n,r;
#include<map>
#include<queue>
#include<set>
map<ll,bool > vis;
ll s;
inline bool check(ll s,int x)
{
int tx=(s&(7ll<<(x*3)))>>(x*3);
for(int i=0;i<n;i++)
{
if(i==x) continue;
int ti=(s&(7ll<<(i*3)))>>(i*3);
if(B[x].t==B[i].t) {
if(B[x].c!=B[i].c) continue;
if(tx+B[x].l<=ti||ti+B[i].l<=tx) continue;
return 0;
} else {
if(tx+B[x].l>B[i].c&&B[i].c>=tx&&
ti<=B[x].c&&B[x].c<B[i].l+ti) {
return 0;
}
}
}
return 1;
}
inline bool done(ll s)
{
for(int i=0;i<n;i++) {
if(B[i].t==1) continue;
int tt= ((s&(7ll<<(3*r)))>>(r*3));
if(B[i].c<tt+B[r].l) continue;
int l=((s&(7ll<<(3*i)))>>(i*3)) , r=l+B[i].l;
if(r<=2||l>2) continue;
return 0;
}
return 1;
}
inline void cover(ll& s,int x,int p)
{
s&=~(7ll<<(x*3));
s|=(ll)p<<(x*3);
}
#define pii pair<ll,int>
#define mp make_pair
int bfs(ll s)
{
if(done(s)) return 1;
queue< pii > q;
q.push(mp(s,0));
vis.clear();
vis[s]=1;
while(!q.empty()) {
pii tt=q.front(); q.pop();
ll u=tt.first;
int d=tt.second+1;
for(int i=0;i<n;i++) {
int p=(u&(7ll<<(i*3)))>>(i*3);
for(int j=1;j<=p;j++) {
ll v=u;
cover(v,i,p-j);
if(!check(v,i)) break;
if(done(v)) return d+1;
if(vis[v]) continue;
vis[v]=1;
q.push(mp(v,d));
}
for(int j=1;p+j+B[i].l<=6;j++) {
ll v=u;
cover(v,i,p+j);
if(!check(v,i)) break;
if(done(v)) return d+1;
if(vis[v]) continue;
vis[v]=1;
q.push(mp(v,d));
}
}
}
return -1;
}
int main()
{
while(cin>>n&&n)
{
ll s=0;
for(int i=0;i<n;i++)
{
int t,lx,ly,rx,ry;
cin>>t>>lx>>ly>>rx>>ry;
if(lx==rx) {
B[i].t=0;
B[i].l=ry-ly+1;
B[i].c=lx;
s|=((ll)ly<<(3*i));
}
else {
B[i].t=1;
B[i].l=rx-lx+1;
B[i].c=ly;
s|=((ll)lx<<(3*i));
}
}
cin>>r;
cout<<bfs(s)<<endl;
}
}

133
HDOJ/3901_autoAC.cpp Normal file
View File

@ -0,0 +1,133 @@
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
#define pb push_back
typedef pair <int, int> pt;
const int BUF_SIZE = 100000, SON = 26;
char s[BUF_SIZE + 1], t[BUF_SIZE + 1];
int lens, lent;
vector <pt> vec;
bool fir, las;
struct node_t {
node_t *son[SON], *fail;
vector <int> lis;
} node_pool[BUF_SIZE + 1], *node_idx, *root;
node_t *node_alloc() {
node_t *ret = node_idx ++;
memset(ret -> son, 0, sizeof(ret -> son));
ret -> fail = NULL;
ret -> lis.clear();
return ret;
}
void init() {
node_idx = node_pool;
root = node_alloc();
}
void ins(char *st, char *ed, int p) {
node_t *pos = root;
while (st != ed) {
int t = *(st ++) - 'a';
if (!pos -> son[t]) pos -> son[t] = node_alloc();
pos = pos -> son[t];
}
pos -> lis.pb(p);
}
void build() {
static queue <node_t *> q;
for (int i = 0; i < SON; i ++)
if (root -> son[i]) {
root -> son[i] -> fail = root;
q.push(root -> son[i]);
}
else root -> son[i] = root;
while (q.size()) {
node_t *u = q.front();
q.pop();
for (int i = 0; i < SON; i ++)
if (u -> son[i]) {
u -> son[i] -> fail = u -> fail -> son[i];
for (vector <int>::iterator it = u -> fail -> son[i] -> lis.begin(); it != u -> fail -> son[i] -> lis.end(); it ++)
u -> son[i] -> lis.pb(*it);
q.push(u -> son[i]);
}
else u -> son[i] = u -> fail -> son[i];
}
}
bool solve(int lb, int rb, bool st, bool ed) {
init();
int pat = 0;
static int cnt[BUF_SIZE];
memset(cnt, 0, sizeof(cnt));
for (int i = lb; i < rb; )
if (t[i] == '?') i ++;
else {
int j = i;
while (j < rb && t[j] != '?') j ++;
ins(t + i, t + j, j - 1 - lb);
i = j;
pat ++;
}
build();
node_t *pos = root;
for (int i = 0; i < lens; i ++) {
int p = s[i] - 'a';
pos = pos -> son[p];
node_t *tmp = pos;
for (vector <int>::iterator it = tmp -> lis.begin(); it != tmp -> lis.end(); it ++) {
int q = *it;
if (i - q >= 0)
cnt[i - q] ++;
}
}
for (int i = 0; i < lens; i ++)
if (cnt[i] == pat) {
if (vec.empty()) {
if (!fir && st && i != 0) continue;
if (!las && ed && i + rb - lb != lens) continue;
vec.pb(make_pair(i, i + rb - lb));
return 1;
}
else {
vector <pair <int, int> >::reverse_iterator it = vec.rbegin();
if (i >= it -> second) {
if (ed && !las && i + rb - lb != lens) continue;
vec.pb(make_pair(i, i + rb - lb));
return 1;
}
}
}
return 0;
}
int main() {
while (scanf("%s%s", s, t) != EOF) {
lens = strlen(s), lent = strlen(t);
fir = (t[0] == '*'), las = (t[lent - 1] == '*');
vec.clear();
bool fail = 0;
int split = 0;
int real_end = lent;
while (real_end && t[real_end - 1] == '*') real_end --;
for (int i = 0; i < lent; )
if (t[i] == '*') i ++;
else {
int j = i;
while (j < lent && t[j] != '*') j ++;
if (!solve(i, j, split == 0, j == real_end)) {
fail = 1;
split ++;
break;
}
i = j;
split ++;
}
if (split == 0) printf("YES\n");
else if (fail) printf("NO\n");
else printf("YES\n");
}
return 0;
}

52
HDOJ/3902_autoAC.cpp Normal file
View File

@ -0,0 +1,52 @@
#include<iostream>
using namespace std;
#define N 40005
struct node{
double x,y;
}p[N];
int n;
double cal_dis(int x,int y){
double x1=p[x].x,y1=p[x].y;
double x2=p[y].x,y2=p[y].y;
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
}
int main(void){
while(~scanf("%d",&n)){
int k=1;
for(int i=1;i<=n;i++){
scanf("%lf%lf",&p[k].x,&p[k].y);
if(k!=1&&k%2){
p[k-1].x=(p[k-2].x+p[k].x)/2.0;
p[k-1].y=(p[k-2].y+p[k].y)/2.0;
}
k+=2;
}
p[k-1].x=(p[1].x+p[k-2].x)/2.0;
p[k-1].y=(p[1].y+p[k-2].y)/2.0;
bool flag=0;
for(int i=1;i<=n;i++){
double x1=p[i].x-p[i+n].x;
double y1=p[i].y-p[i+n].y;
int j,k;
k=i-1;
j=i+1;
for(;j<=i+n;j++,k--){
if(k<=0) k=2*n;
double x2=p[j].x-p[k].x;
double y2=p[j].y-p[k].y;
if(x1*x2+y1*y2!=0)
break;
if(cal_dis(i,j)!=cal_dis(i,k))
break;
}
if(j>i+n){
flag=1;
break;
}
}
if(flag)
printf("YES\n");
else
printf("NO\n");
}
}

18
HDOJ/3903_autoAC.cpp Normal file
View File

@ -0,0 +1,18 @@
#include<stdio.h>
#include<math.h>
int main()
{
__int64 t, a, b, c, n, m, k;
scanf("%I64d",&t);
while(t--)
{
scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&n,&m,&k);
__int64 s = 4 * a * a * b * b - (a * a + b * b - c * c) * (a * a + b * b - c * c);
__int64 tmp = sqrt(s);
if(tmp * tmp == s)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}

48
HDOJ/3905_autoAC.cpp Normal file
View File

@ -0,0 +1,48 @@
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int dp[1005][1005],sum[1005],a[1005],s[1005][1005];
int main()
{
int n,m,r;
while(scanf("%d%d%d",&n,&m,&r)!=EOF)
{
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
sum[i]=sum[i-1]+a[i];
}
memset(dp,-1,sizeof(dp));
memset(s,-0x1f1f1f1f,sizeof(s));
dp[0][0]=0;s[0][0]=-sum[1];
for(int i=1;i<=n;i++)
{
if(i>=r)
{
dp[0][i]=sum[i];
}
dp[i][i]=0;
s[0][i]=max(s[0][i-1],dp[0][i]-sum[i+1]);
}
for(int i=1;i<=m;i++)
{
for(int j=i;j<=n;j++)
{
if(dp[i-1][j-1]!=-1)
dp[i][j]=max(dp[i-1][j-1],dp[i][j]);
if(j-r>=i&&s[i-1][j-r-1]!=-0x1f1f1f1f)
dp[i][j]=max(dp[i][j],sum[j]+s[i-1][j-r-1]);
if(dp[i][j]!=-1)
s[i][j]=max(s[i][j-1],dp[i][j]-sum[j+1]);
else
s[i][j]=s[i][j-1];
}
}
printf("%d\n",dp[m][n]);
}
return 0;
}

85
HDOJ/3907_autoAC.cpp Normal file
View File

@ -0,0 +1,85 @@
#include <iostream>
#include <string.h>
using namespace std;
struct e{
int data;
int weight;
e *next;
};
e edge[1001];
int n;
void add(int s,int t,int weight){
e *p=new e;
p->data=t;
p->next=edge[s].next;
p->weight=weight;
edge[s].next=p;
}
int s[1001],q[1001];
int f[1001][1001];
int solve(int s1,int t1,int w){
int ans1=0;
int ans2=0;
int i,j,k;
if(f[s1][t1]!=-1) return f[s1][t1];
e *p=edge[s1].next;
e *q1=p;
if(w>q[s1])
{
while(p)
{
solve(p->data,s1,p->weight);
ans1+=f[p->data][s1];
p=p->next;
}
f[s1][t1]=ans1+s[s1];
}
else
{
while(p)
{
solve(p->data,s1,p->weight);
ans1+=f[p->data][s1];
p=p->next;
}
while(q1)
{
solve(q1->data,t1,w+q1->weight);
ans2+=f[q1->data][t1];
q1=q1->next;
}
f[s1][t1]=min(ans2,ans1+s[s1]);
}
return f[s1][t1];
}
void read(){
int i,j,k,s1,t,root;
int cas;
cin>>cas;
while(cas--)
{
cin>>n;
memset(edge,0,sizeof(edge));
memset(f,-1,sizeof(f));
for(i=1;i<=n;i++)
{
cin>>j>>k>>s1>>t;
if(j!=0) add(j,i,t);
else root=i;
q[i]=k;
s[i]=s1;
}
e *p=edge[root].next;
int ans=0;
while(p)
{
ans+=solve(p->data,root,p->weight);
p=p->next;
}
cout<<ans<<endl;
}
}
int main(){
read();
return 0;
}

33
HDOJ/3908_autoAC.cpp Normal file
View File

@ -0,0 +1,33 @@
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define N 1000
int co_prime[N];
int unco_prime[N];
int s[N];
int Gcd(int a, int b)
{
return a%b?Gcd(b,a%b):b;
}
int main()
{
int t,n,i,j,sum;
scanf("%d",&t);
while(t--){
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&s[i]);
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
if(i == j)continue;
if(Gcd(s[i],s[j]) == 1)co_prime[i] ++;
else unco_prime[i] ++;
}
}
sum = 0;
for(i=1;i<=n;i++)sum += co_prime[i] * unco_prime[i];
printf("%d\n",n*(n-1)*(n-2)/6- sum/2);
for(i=0;i<=n;i++)co_prime[i] = unco_prime[i] = 0;
}
return 0;
}

11
HDOJ/3910_autoAC.cpp Normal file
View File

@ -0,0 +1,11 @@
#include<stdio.h>
int main()
{
int A,B,C;
while(scanf("%d%d%d",&A,&B,&C)!=EOF)
{
double x=(double)(B+C)/(A+B+C*2);
printf("%.6lf\n",(1-x)*B-x*C);
}
return 0;
}

147
HDOJ/3911_autoAC.cpp Normal file
View File

@ -0,0 +1,147 @@
#include<iostream>
using namespace std;
struct node{
int lone,lzero;
int rone,rzero;
int tmax0,tmax1;
int flag;
int l,r;
int mlen;
}p[100001*4];
int a[100001];
int max(int x,int y)
{
return x>y?x:y;
}
int min(int x,int y)
{
return x<y?x:y;
}
void update_info(int n)
{
p[n].lone=p[n*2].lone;
if(p[n*2].lone==p[n*2].mlen)
p[n].lone+=p[n*2+1].lone;
p[n].lzero=p[n*2].lzero;
if(p[n*2].lzero==p[n*2].mlen)
p[n].lzero+=p[n*2+1].lzero;
p[n].rone=p[n*2+1].rone;
if(p[n*2+1].rone==p[n*2+1].mlen)
p[n].rone+=p[n*2].rone;
p[n].rzero=p[n*2+1].rzero;
if(p[n*2+1].rzero==p[n*2+1].mlen)
p[n].rzero+=p[n*2].rzero;
p[n].tmax0=max(p[n*2].tmax0,p[n*2+1].tmax0);
p[n].tmax0=max(p[n].tmax0,p[n*2].rzero+p[n*2+1].lzero);
p[n].tmax1=max(p[n*2].tmax1,p[n*2+1].tmax1);
p[n].tmax1=max(p[n].tmax1,p[n*2].rone+p[n*2+1].lone);
}
void build(int l,int r,int n)
{
p[n].l=l;
p[n].r=r;
p[n].flag=0;
p[n].mlen=(r-l+1);
if(l==r)
{
if(a[l]==1)
{
p[n].lone=1;
p[n].lzero=0;
p[n].rone=1;
p[n].rzero=0;
p[n].tmax0=0;
p[n].tmax1=1;
}
else
{
p[n].lone=0;
p[n].lzero=1;
p[n].rone=0;
p[n].rzero=1;
p[n].tmax0=1;
p[n].tmax1=0;
}
return ;
}
int mid=(l+r)/2;
build(l,mid,n*2);
build(mid+1,r,n*2+1);
update_info(n);
}
void pushdown(int n)
{
p[n*2].flag=p[n*2].flag^1;
p[n*2+1].flag=p[n*2+1].flag^1;
swap(p[n*2].lone,p[n*2].lzero);
swap(p[n*2].rone,p[n*2].rzero);
swap(p[n*2].tmax1,p[n*2].tmax0);
swap(p[n*2+1].lone,p[n*2+1].lzero);
swap(p[n*2+1].rone,p[n*2+1].rzero);
swap(p[n*2+1].tmax1,p[n*2+1].tmax0);
p[n].flag=0;
}
void insert(int x,int y,int n)
{
if(x==p[n].l&&y==p[n].r)
{
swap(p[n].lone,p[n].lzero);
swap(p[n].rzero,p[n].rone);
swap(p[n].tmax1,p[n].tmax0);
p[n].flag=p[n].flag^1;
return ;
}
if(p[n].flag==1)
pushdown(n);
int mid=(p[n].l+p[n].r)/2;
if(y<=mid)
insert(x,y,n*2);
else if(x>mid)
insert(x,y,n*2+1);
else
{
insert(x,mid,n*2);
insert(mid+1,y,n*2+1);
}
update_info(n);
}
int sum(int x,int y,int n)
{
if(x==p[n].l&&y==p[n].r)
return p[n].tmax1;
int mid=(p[n].l+p[n].r)/2;
if(p[n].flag==1)
pushdown(n);
if(y<=mid)
return sum(x,y,n*2);
else if(x>mid)
return sum(x,y,n*2+1);
else
{
int left=0,right=0,midden=0;
midden=min(mid-x+1,p[n*2].rone)+min(y-mid,p[n*2+1].lone);
left=sum(x,mid,n*2);
right=sum(mid+1,y,n*2+1);
return max(midden,max(left,right));
}
}
int main()
{
int n,m,i,nima,x,y;
while(scanf("%d",&n)!=EOF)
{
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
build(1,n,1);
scanf("%d",&m);
while(m--)
{
scanf("%d%d%d",&nima,&x,&y);
if(nima==1)
insert(x,y,1);
else
printf("%d\n",sum(x,y,1));
}
}
return 0;
}

167
HDOJ/3912_autoAC.cpp Normal file
View File

@ -0,0 +1,167 @@
#include <iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<ctime>
using namespace std;
#define N 50009
int R,C,ER,EC,num;
int map1[505][505];
int map2[505][505];
int vis[505][505];
struct Point
{
int x,y,f;
Point(int _x,int _y,int _f){x=_x;y=_y;f=_f;}
};
void init()
{
scanf("%d%d%d%d",&R,&C,&ER,&EC);
memset(vis,0,sizeof(vis));
num=0;
for(int i=0;i<2*R-1;i++)
{
if(i&1)
{
for(int j=0;j<C;j++)
scanf("%d",&map1[i/2][j]);
}
else
{
for(int j=0;j<C-1;j++)
scanf("%d",&map2[i/2][j]);
}
}
}
void dfs(Point s,Point ss)
{
int ff=s.f;
for(;;)
{
if(!vis[s.x][s.y])num++;
vis[s.x][s.y]=1;
if(s.x==ss.x&&s.y==ss.y)
{
if((s.f==3&&ff==0)||(s.f==1&&ff==2))
break;
if(s.f==ff&&ff==0&&(s.y==0||map2[s.x][s.y-1]==1))
break;
if(s.f==ff&&ff==2&&(s.y==C-1||map2[s.x][s.y]==1))
break;
}
if(s.f==0)
{
if(s.y>0&&map2[s.x][s.y-1]==0)
{
s.y--;
s.f=1;
}
else if(s.x+1<R&&map1[s.x][s.y]==0)
{
s.x++;
s.f=0;
}
else if(s.y+1<C&&map2[s.x][s.y]==0)
{
s.y++;
s.f=3;
}
else if(s.x>0&&map1[s.x-1][s.y]==0)
{
s.x--;
s.f=2;
}
}
else if(s.f==1)
{
if(s.x>0&&map1[s.x-1][s.y]==0)
{
s.x--;
s.f=2;
}
else if(s.y>0&&map2[s.x][s.y-1]==0)
{
s.y--;
s.f=1;
}
else if(s.x+1<R&&map1[s.x][s.y]==0)
{
s.x++;
s.f=0;
}
else if(s.y+1<C&&map2[s.x][s.y]==0)
{
s.y++;
s.f=3;
}
}
else if(s.f==2)
{
if(s.y+1<C&&map2[s.x][s.y]==0)
{
s.y++;
s.f=3;
}
else if(s.x>0&&map1[s.x-1][s.y]==0)
{
s.x--;
s.f=2;
}
else if(s.y>0&&map2[s.x][s.y-1]==0)
{
s.y--;
s.f=1;
}
else if(s.x+1<R&&map1[s.x][s.y]==0)
{
s.x++;
s.f=0;
}
}
else if(s.f==3)
{
if(s.x+1<R&&map1[s.x][s.y]==0)
{
s.x++;
s.f=0;
}
else if(s.y+1<C&&map2[s.x][s.y]==0)
{
s.y++;
s.f=3;
}
else if(s.x>0&&map1[s.x-1][s.y]==0)
{
s.x--;
s.f=2;
}
else if(s.y>0&&map2[s.x][s.y-1]==0)
{
s.y--;
s.f=1;
}
}
}
}
void solve()
{
Point s=Point(0,ER,0);
Point ss=Point(R-1,EC,2);
dfs(s,ss);
dfs(ss,s);
if(num==R*C) puts("YES");
else puts("NO");
}
int main()
{
int Case;
scanf("%d",&Case);
while(Case--)
{
init();
solve();
}
return 0;
}

74
HDOJ/3913_autoAC.cpp Normal file
View File

@ -0,0 +1,74 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXV 500
#define MAXE 1000
#define INF 0x7fffffff
int list[MAXV];
char s[MAXV];
int f[MAXV + 1][26];
bool equal[MAXV];
int n;
struct Edge {
int ed, next;
} edge[MAXE];
int head[MAXV], nEdge;
void init() {
memset(head, 0xff, sizeof(head));
nEdge = 0;
}
void addEdge(const int a, const int b) {
edge[nEdge].ed = b;
edge[nEdge].next = head[a];
head[a] = nEdge++;
}
bool find(int cur, int tar){
int i, p;
if (cur >= n) return false;
if (tar >= n) return true;
for (i = head[cur]; ~i; i = edge[cur].next){
p = edge[i].ed;
if (p == tar) return true;
return find(p, tar);
}
return false;
}
int imin(int a, int b){
return a < b ? a : b;
}
void calc(){
int i, j, k;
for (i = 0; i < n - 1; i++){
equal[i] = find(list[i + 1] + 1, list[i] + 1);
}
equal[i] = true;
for (i = n - 1; i >= 0; i--){
for (j = 0; j < 26; j++){
f[i][j] = n + 1;
for (k = j + 1 - equal[i]; k < 26; k++){
f[i][j] = imin(f[i + 1][k], f[i][j]);
}
if (s[list[i]] != j + 'a') f[i][j]++;
}
}
j = n + 1;
for (i = 0; i < 26; i++)
j = imin(j, f[0][i]);
if (j > n) j = -1;
printf("%d\n", j);
}
int main(){
int i;
while(scanf("%d", &n) != EOF){
scanf("%s", s);
init();
memset(f, 0, sizeof(f));
memset(equal, 0, sizeof(equal));
for (i = 0; i < n; i++) scanf("%d", &list[i]);
for (i = 0; i < n - 1; i++){
addEdge(list[i + 1], list[i]);
}
calc();
}
return 0;
}

51
HDOJ/3915_autoAC.cpp Normal file
View File

@ -0,0 +1,51 @@
#include<cstdio>
#include<algorithm>
#define MAXN 110
#define MOD 1000007
using namespace std;
int a[MAXN], g[MAXN][MAXN];
int Gauss(int n) {
int i, j, r, c, cnt;
for (c = cnt = 0; c < n; c++) {
for (r = cnt; r < 31; r++) {
if (g[r][c])
break;
}
if (r < 31) {
if (r != cnt) {
for (i = 0; i < n; i++)
swap(g[r][i], g[cnt][i]);
}
for (i = cnt + 1; i < 31; i++) {
if (g[i][c]) {
for (j = 0; j < n; j++)
g[i][j] ^= g[cnt][j];
}
}
cnt++;
}
}
return n - cnt;
}
int main() {
int c;
int n, i, j;
int ans, vary;
scanf("%d", &c);
while (c--) {
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
for (i = 0; i < 31; i++) {
for (j = 0; j < n; j++)
g[i][j] = (a[j] >> i) & 1;
}
vary = Gauss(n);
for (ans = 1; vary--;) {
ans <<= 1;
ans %= MOD;
}
printf("%d\n", ans);
}
return 0;
}

53
HDOJ/3916_autoAC.cpp Normal file
View File

@ -0,0 +1,53 @@
#include<stdio.h>
#include<string.h>
#define MAXN 10010
#define INF 0x3fffffff
int v[MAXN],cur[MAXN];
int min(int x,int y)
{
return x<y?x:y;
}
int main()
{
int n,t,ans;
int i,j,s,sub;
for(scanf("%d",&t);t;t--)
{
scanf("%d",&n);
if(!n)
{
puts("0");
continue;
}
for(i=1;i<=n;i++)
scanf("%d",v+i);
memset(cur,0,sizeof(cur));
v[n+1]=-INF;
for(i=1;v[i]==0;i++);
j=i;
s=0;
ans=INF;
while(i<=n)
{
if(i>j)
{
s=0;
j=i;
}
while(j<=n && v[j]-cur[j]<=v[j+1])
j++;
if(ans>j-i+1)
ans=j-i+1;
sub=v[j]-cur[j]-v[j+1];
cur[j]+=min(sub,v[i]-s);
s+=min(sub,v[i]-s);
while(!(v[i]-s))
{
s-=cur[i];
i++;
}
}
printf("%d\n",ans);
}
return 0;
}

116
HDOJ/3917_autoAC.cpp Normal file
View File

@ -0,0 +1,116 @@
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<memory.h>
using namespace std;
const int M=10002;
const int INF=(1e9)-1;
int t,n,m,tot;
int gap[M],dis[M],pre[M],head[M],cur[M],s[M];
int NE,NV,sink,a[M],b[M],c[M],d[M];
struct Node
{
int c,pos,next;
} E[M*4];
#define FF(i,NV) for(int i=0;i<NV;i++)
int sap(int s,int t)
{
memset(dis,0,sizeof(int)*(NV+1));
memset(gap,0,sizeof(int)*(NV+1));
FF(i,NV) cur[i] = head[i];
int u = pre[s] = s,maxflow = 0,aug =INF;
gap[0] = NV;
while(dis[s] < NV)
{
loop:
for(int &i = cur[u]; i != -1; i = E[i].next)
{
int v = E[i].pos;
if(E[i].c && dis[u] == dis[v] + 1)
{
aug=min(aug,E[i].c);
pre[v] = u;
u = v;
if(v == t)
{
maxflow += aug;
for(u = pre[u]; v != s; v = u,u = pre[u])
{
E[cur[u]].c -= aug;
E[cur[u]^1].c += aug;
}
aug =INF;
}
goto loop;
}
}
if( (--gap[dis[u]]) == 0) break;
int mindis = NV;
for(int i = head[u]; i != -1 ; i = E[i].next)
{
int v = E[i].pos;
if(E[i].c && mindis > dis[v])
{
cur[u] = i;
mindis = dis[v];
}
}
gap[ dis[u] = mindis+1 ] ++;
u = pre[u];
}
return maxflow;
}
void addEdge(int u,int v,int c )
{
E[NE].c = c;
E[NE].pos = v;
E[NE].next = head[u];
head[u] = NE++;
E[NE].c = 0;
E[NE].pos = u;
E[NE].next = head[v];
head[v] = NE++;
}
int main()
{
int n, m,sum, source, sink, vn,k;
while(scanf("%d %d", &n, &m),(n||m))
{
NE=0,tot=0;
sum = 0;
source = 0;
sink=m+1;
NV=sink+1;
memset(head, -1, sizeof(head));
memset(s,0,sizeof(s));
for(int i=1;i<=m;i++)
{
scanf("%d",&vn);
addEdge(source,i,vn);
sum+=vn;
}
scanf("%d",&k);
for(int i=1;i<=k;i++)
{
scanf("%d%d%d%d",&a[i],&b[i],&d[i],&c[i]);
s[d[i]]+=c[i];
}
for(int i=1;i<=k;i++)
{
for(int j=1;j<=k;j++)
{
if(i!=j&&b[i]==a[j]&&d[i]!=d[j])
{
addEdge(d[i],d[j],INF);
}
}
}
for(int i=1;i<=m;i++)
{
addEdge(i,sink,s[i]);
}
printf("%d\n",sum-sap(source,sink));
}
return 0;
}

215
HDOJ/3918_autoAC.cpp Normal file
View File

@ -0,0 +1,215 @@
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <cmath>
#define MAXN 300
#define eps 1e-5
#define max(a,b) (a>b?a:b)
#define min(a,b) (a<b?a:b)
using namespace std;
struct point {double x,y;};
struct point pnt[MAXN],ll[MAXN],rr[MAXN],center;
int N,M,l_pos,r_pos;
double ans,H;
bool ne;
point bcenter(point pnt[], int n)
{
point p, s;
if(n==1)
return pnt[0];
if(n==2)
{
s.x=(pnt[0].x+pnt[1].x)/2;
s.y=(pnt[0].y+pnt[1].y)/2;
return s;
}
double tp, area = 0, tpx = 0, tpy = 0;
p.x = pnt[0].x; p.y = pnt[0].y;
for (int i = 1; i <= n; ++i)
{ // point: 0 ~ n-1
s.x = pnt[(i == n) ? 0 : i].x;
s.y = pnt[(i == n) ? 0 : i].y;
tp = (p.x * s.y - s.x * p.y); area += tp / 2;
tpx += (p.x + s.x) * tp; tpy += (p.y + s.y) * tp;
p.x = s.x; p.y = s.y;
}
s.x = tpx / (6 * area); s.y = tpy / (6 * area);
return s;
}
void Print()
{
int i;
printf("-------------------------------------\n");
for(i=0;i<M;i++)
printf("%.2lf %.2lf\n",ll[i].x,ll[i].y);
for(i=0;i<N;i++)
printf("%.2lf %.2lf\n",rr[i].x,rr[i].y);
printf("-------------------------------------\n");
}
point get_point(point c,point a,point b)
{
point res;
double dx,dy;
dx=fabs(a.x-b.x);
dy=b.y-a.y;
res.y=c.y;
if(fabs(a.x-b.x)<=eps)
res.x=a.x;
else
{
if(a.x<b.x)
res.x=dx*(c.y-a.y)*1.0/dy+a.x;
else
res.x=a.x-dx*(c.y-a.y)*1.0/dy;
}
return res;
}
void ini()
{
M=N=0;
l_pos=r_pos=0;
ans=H=0;
memset(pnt,0,sizeof(pnt));
memset(ll,0,sizeof(ll));
memset(rr,0,sizeof(rr));
}
void Init()
{
int i;
ini();
scanf("%d%d",&M,&N);
for(i=0;i<M;i++)
scanf("%lf%lf",&ll[i].x,&ll[i].y);
for(i=0;i<N;i++)
scanf("%lf%lf",&rr[i].x,&rr[i].y);
}
bool Judge(point o)
{
if((o.x-ll[0].x>=eps)&&(rr[0].x-o.x>=eps))
return true;
return false;
}
bool fuck(double mid,int l_pos,int r_pos)
{
int i;
point temp,now1,now2;
temp.x=1;temp.y=mid;
int cnt=0;
if(fabs(ll[l_pos].y-rr[r_pos].y)<=eps)
{
for(i=l_pos;i>=0;i--)
pnt[cnt++]=ll[i];
for(i=0;i<=r_pos;i++)
pnt[cnt++]=rr[i];
}
else if(ll[l_pos].y<rr[r_pos].y)
{
now1=get_point(temp,ll[l_pos],ll[l_pos+1]);
now2=get_point(temp,rr[r_pos-1],rr[r_pos]);
pnt[cnt++]=now1;
for(i=l_pos;i>=0;i--)
pnt[cnt++]=ll[i];
for(i=0;i<r_pos;i++)
pnt[cnt++]=rr[i];
pnt[cnt++]=now2;
}
else
{
now1=get_point(temp,ll[l_pos-1],ll[l_pos]);
now2=get_point(temp,rr[r_pos],rr[r_pos+1]);
pnt[cnt++]=now1;
for(i=l_pos-1;i>=0;i--)
pnt[cnt++]=ll[i];
for(i=0;i<=r_pos;i++)
pnt[cnt++]=rr[i];
pnt[cnt++]=now2;
}
center=bcenter(pnt,cnt);
return Judge(center);
}
void Solve()
{
ans=ll[0].y;;
double l,r,mid;
int i,cnt;
point now;
l_pos=r_pos=1;
while(true)
{
cnt=0;
if(l_pos==M||r_pos==N) break;
if(ll[l_pos].y<=rr[r_pos].y)
{
for(i=l_pos;i>=0;i--)
pnt[cnt++]=ll[i];
for(i=0;i<r_pos;i++)
pnt[cnt++]=rr[i];
now=get_point(ll[l_pos],rr[r_pos-1],rr[r_pos]);
pnt[cnt++]=now;
center=bcenter(pnt,cnt);
ne=Judge(center);
if(!ne)
{
l=max(rr[r_pos-1].y,ll[l_pos-1].y);r=ll[l_pos].y;
while(fabs(l-r)>eps)
{
mid=(l+r)/2.0;
if(fuck(mid,l_pos,r_pos-1))
l=mid;
else
r=mid;
}
ans=max(ans,l);
break;
}
else
{
ans=max(ans,ll[l_pos].y);
l_pos++;
}
}
else
{
now=get_point(rr[r_pos],ll[l_pos-1],ll[l_pos]);
pnt[cnt++]=now;
for(i=l_pos-1;i>=0;i--)
pnt[cnt++]=ll[i];
for(i=0;i<=r_pos;i++)
pnt[cnt++]=rr[i];
center=bcenter(pnt,cnt);
ne=Judge(center);
if(!ne)
{
l=max(ll[l_pos-1].y,rr[r_pos-1].y);r=rr[r_pos].y;
while(fabs(l-r)>eps)
{
mid=(l+r)/2.0;
if(fuck(mid,l_pos-1,r_pos))
l=mid;
else
r=mid;
}
ans=max(ans,l);
break;
}
else
{
ans=max(ans,rr[r_pos].y);
r_pos++;
}
}
}
printf("%.3lf\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
Init();
Solve();
}
return 0;
}

66
HDOJ/3920_autoAC.cpp Normal file
View File

@ -0,0 +1,66 @@
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
double dis[21][21],dp[1<<21];
int n,fx,fy,mac;
struct node
{
int x,y;
}nd[21];
double DIS(double x,double y,double xx,double yy)
{
return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
}
bool cmp(node a,node b)
{
return DIS(a.x,a.y,fx,fy)<DIS(b.x,b.y,fx,fy);
}
double DP(int sta)
{
if(dp[sta]!=0x7fffffff)
return dp[sta];
if(sta==0) {dp[0]=0.0;}
else
{
int tem=sta,i=0;
for(i=0;i<20;i++)
{
if((1<<i)&sta)break;
}
for(int j=i+1;j<2*n;j++)
{
if((sta&(1<<j))==0)continue;
dp[sta]=min(DP(sta-(1<<j)-(1<<i))+dis[i][j],dp[sta]);
}
}
return dp[sta];
}
int main()
{
int c,ca=0;
scanf("%d",&c);
while(c--)
{
ca++;
scanf("%d%d",&fx,&fy);
scanf("%d",&n);
for(int i=0;i<2*n;i++)
{
scanf("%d%d",&nd[i].x,&nd[i].y);
}
sort(nd,nd+2*n,cmp);
for(int i=0;i<2*n;i++)
for(int j=i+1;j<2*n;j++)
{
dis[i][j]=DIS(nd[i].x,nd[i].y,fx,fy)+DIS(nd[i].x*1.0,nd[i].y*1.0,nd[j].x*1.0,nd[j].y*1.0);
}
printf("Case #%d: ",ca);
for(int i=0;i<(1<<2*n);i++)
dp[i]=0x7fffffff;
printf("%.2f\n",DP((1<<(2*n))-1));
}
}

155
HDOJ/3921_autoAC.cpp Normal file
View File

@ -0,0 +1,155 @@
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
struct Point
{
double x, y;
} node[201];
struct T_T
{
int id;
double dis;
} que[201];
double sx, sy;
double ans;
double dis[201];
double map[201][201];
int q[201][201], q2[201][201];
int n;
int m;
bool vis[201];
int ra, rb, rc, rd;
double rmin;
double rdis;
double dist(int i, int j)
{
return sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x)
+ (node[i].y - node[j].y) * (node[i].y - node[j].y));
}
bool cmp(T_ a, T_ b)
{
return a.dis < b.dis;
}
void init()
{
for(int i = 0; i < m; i++) dis[i] = dist(i, m);
for(int i = 0; i < m; i++)
for(int j = i + 1; j < m; j++)
map[i][j] = map[j][i] = dist(i, j);
for(int i = 0; i < m; i++)
{
int temp = 0;
for(int j = 0; j < m; j++)
if(i != j)
{
que[temp].id = j;
que[temp].dis = dis[j] + map[j][i];
temp++;
}
sort(que, que + temp, cmp);
for(int j = 0; j < temp; j++)
q[i][j] = que[j].id;
}
for(int i = 0; i < m; i++)
{
int temp = 0;
for(int j = 0; j < m; j++)
if(i != j)
{
que[temp].id = j;
que[temp].dis = map[i][j];
temp++;
}
sort(que, que + temp, cmp);
for(int j = 0; j < temp; j++)
q2[i][j] = que[j].id;
}
}
void solve()
{
rmin = -1;
int a, b, c, d;
for(b = 0; b < m; b++)
if(!vis[b])
{
for(c = 0; c < m; c++)
if(!vis[c] && b != c)
{
int t = 0;
a = q[b][t];
while(vis[a] || a == c)
{
t++;
a = q[b][t];
}
t = 0;
d = q2[c][t];
while(vis[d] || d == a || d == b)
{
t++;
d = q2[c][t];
}
double cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
double cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
{
rmin = cou;
rdis = cdis;
ra = a, rb = b, rc = c, rd = d;
}
t = 0;
d = q2[c][t];
while(vis[d] || d == b)
{
t++;
d = q2[c][t];
}
t = 0;
a = q[b][t];
while(vis[a] || a == c || a == d)
{
t++;
a = q[b][t];
}
cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
{
rmin = cou;
rdis = cdis;
ra = a, rb = b, rc = c, rd = d;
}
}
}
vis[ra] = 1;
vis[rb] = 1;
vis[rc] = 1;
vis[rd] = 1;
ans += rmin;
}
int main()
{
int T;
int cas = 1;
scanf("%d", &T);
while(T--)
{
scanf("%lf%lf", &sx, &sy);
scanf("%d", &n);
m = 4 * n;
for(int i = 0; i < m; i++) scanf("%lf%lf", &node[i].x, &node[i].y);
node[m].x = sx;
node[m].y = sy;
init();
ans = 0;
memset(vis, 0, sizeof(vis));
for(int i = 0; i < n; i++)
{
solve();
}
printf("Case #%d: %0.2lf\n", cas++, ans);
}
return 0;
}

92
HDOJ/3923_autoAC.cpp Normal file
View File

@ -0,0 +1,92 @@
#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
const int mod=1000000007;
__int64 n,c;
__int64 fun(__int64 a,__int64 b)
{
__int64 t=1,y=a;
for(int i=1;i<=b;i*=2)
{
if(b&i)
t=t*y%mod;
y=y*y%mod;
}
return t;
}
__int64 euler(__int64 a)
{
__int64 ans=a;
for(int i=2;i<=a;i++)
{
if(a%i==0)
ans-=ans/i;
while(a%i==0)
a/=i;
}
if(a>1)
ans-=ans/a;
return ans;
}
__int64 Extend_euclid(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
__int64 d=0,t=0;
if(b==0)
{
x=1;
y=0;
return a;
}
else
{
d=Extend_euclid(b,a%b,x,y);
t=x;
x=y;
y=t-a/b*y;
}
return d;
}
__int64 Bignum_Div(__int64 a,__int64 b)
{
__int64 x=0,y=0;
Extend_euclid(b,mod,x,y);
__int64 ans= a*x%mod;
while(ans<0)
ans+=mod;
return ans;
}
int main()
{
__int64 ans=0,t=1,T=0;
scanf("%I64d",&T);
while(T--)
{
scanf("%I64d %I64d",&c,&n);
ans=0;
for(int i=1;i<=n;i++)
{
if(n%i==0)
{
ans+=fun(c,i)*euler(n/i);
ans%=mod;
}
}
if(n&1)
{
ans+=n*fun(c,n/2+1);
ans%=mod;
}
else
{
ans+=n/2*( fun(c,n/2)+fun(c,n/2+1));
ans%=mod;
}
ans=Bignum_Div(ans,2*n);
printf("Case #%I64d: %I64d\n",t++,ans);
}
return 0;
}

100
HDOJ/3924_autoAC.cpp Normal file
View File

@ -0,0 +1,100 @@
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
typedef __int64 LL;
const int MAX=30;
const int LIM=21;
LL num[MAX],rig[MAX],total[MAX];
int b[4];
LL gs(int L)
{
LL res=0;
for(int i=0;i<=L;i++)
{
for(int j=i;j<=L;j++)
{
int k=L-i-j;
if(j>k) continue;
b[0]=i;
b[1]=j;
b[2]=k;
do
{
res+=num[b[0]]*num[b[1]]*num[b[2]];
}while(next_permutation(b,b+3));
}
}
return res;
}
LL getR(int L)
{
LL res=0;
for(int i=0;i<=L;i++)
{
res+=num[i]*num[L-i];
}
return res;
}
void init()
{
num[0]=num[1]=1;
for(int i=2;i<=LIM;i++) num[i]=gs(i-1);
total[0]=0;
for(int i=1;i<=LIM;i++) total[i]=total[i-1]+num[i];
rig[0]=1;
for(int i=1;i<=LIM;i++) rig[i]=getR(i);
}
int getNN(LL N)
{
for(int i=1;i<=LIM;i++) if(total[i]>=N) return i;
}
void dfs(int L,LL N)
{
if(L==1) {printf("X");return ;}
int x=L-1;
int ll,mm,rr;
for(ll=0;N>num[ll]*rig[x-ll];ll++) N-=num[ll]*rig[x-ll];
if(ll)
{
printf("(");
dfs(ll,(N-1)/rig[x-ll]+1);
printf(")");
}
N%=rig[x-ll];
if(N==0) N=rig[x-ll];
x-=ll;
for(mm=0;N>num[mm]*num[x-mm];mm++) N-=num[mm]*num[x-mm];
if(mm)
{
printf("(");
dfs(mm,(N-1)/num[x-mm]+1);
printf(")");
}
N%=num[x-mm];
if(N==0) N=num[x-mm];
x-=mm;
if(x)
{
printf("(");
dfs(x,N);
printf(")");
}
printf("X");
}
int main()
{
init();
int T;scanf("%d",&T);
int CN=0;
while(T--)
{
LL N;scanf("%I64d",&N);
int nn=getNN(N);
printf("Case #%d: ",++CN);
dfs(nn,N-total[nn-1]);
puts("");
}
return 0;
}

103
HDOJ/3925_autoAC.cpp Normal file
View File

@ -0,0 +1,103 @@
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 100 + 10;
bool cmp(char *s, int high, int low, char *sub)
{
int j = 0;
for(int i = high; i <= low; i++) if(s[i] != sub[j++]) return 0;
return 1;
}
int cmpp(char *a, char *b)
{
int len_a = strlen(a), len_b = strlen(b), len = min(len_a, len_b), i;
if(len_a != len_b)
{
if(len_a > len_b) return 1;
else return -1;
}
else
{
for(i = 0; i < len; i++)
{
if(a[i] > b[i]) return 1;
if(a[i] < b[i]) return -1;
}
return 0;
}
}
int to_int(char *s, int high, int low)
{
int ret = 0;
for(int i = high; i <= low; i++) ret = ret*10 + s[i]-'0';
return ret;
}
int main()
{
int i, j, k, u, v, cnt = 1, T;
char a[maxn], b[maxn], B[maxn], c[maxn], minn[maxn];
scanf("%d", &T);
while(T--)
{
scanf("%s%s", a, b);
int len_a = strlen(a), len_b = strlen(b);
for(i = 0; i < maxn; i++) minn[i] = '9';
for(i = len_b; i < maxn; i++) b[i] = '0'; b[maxn-1] = 0;
int bb = to_int(b, 0, len_b-1);
if(len_a < len_b)
{
int aa = to_int(a, 0, len_a-1);
printf("Case #%d: %d\n", cnt++, bb-aa);
continue;
}
bool ok = 0;
for(i = len_a-len_b; i >= 0; i--)
{
int aa = to_int(a, i, i+len_b-1);
if(aa == bb)
{
ok = 1;
break;
}
else
{
for(u = 0; u < maxn; u++) B[u] = b[u];
for(j = len_a-1, k = len_a-1-i; j >= i; j--, k--)
{
if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
else
{
if(k-1 >= 0) B[k-1]--;
c[k] = B[k] + 10 - a[j] + '0';
}
}
c[len_a-i] = 0;
for(v = 0; v < len_a-i; v++) if(c[v] != '0') break;
if(v != 0) for(u = 0; v <= len_a-i; u++,v++) c[u] = c[v];
if(cmpp(c, minn) < 0) for(u = 0; u <= len_a-i; u++) minn[u] = c[u];
}
}
if(ok) printf("Case #%d: %d\n", cnt++, 0);
else
{
for(u = 0; u < maxn; u++) B[u] = b[u];
for(j = len_a-1, k = len_a; j >= 0; j--, k--)
{
if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
else
{
B[k-1]--;
c[k] = B[k] + 10 - a[j] + '0';
}
}
c[0] = B[0];
c[len_a+1] = 0;
for(v = 0; v < len_a+1; v++) if(c[v] != '0') break;
if(v != 0) for(u = 0; v <= len_a+1; u++,v++) c[u] = c[v];
if(cmpp(c, minn) == -1) for(u = 0; u <= len_a+1; u++) minn[u] = c[u];
printf("Case #%d: %s\n", cnt++, minn);
}
}
return 0;
}

109
HDOJ/3926_autoAC.cpp Normal file
View File

@ -0,0 +1,109 @@
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<climits>
#include<algorithm>
using namespace std;
#define MAXN 10010
int pre1[MAXN], pre2[MAXN];
int num1, num2;
struct graph
{
int son;
bool ring;
};
graph g1[MAXN], g2[MAXN];
bool cmb(const graph &g1, const graph &g2)
{
if(g1.son < g2.son)
return true;
else if(g1.son == g2.son && g1.ring < g2.ring)
return true;
else
return false;
}
int find(int x, int pre[])
{
return x == pre[x] ? x : find(pre[x], pre);
}
void join(int x, int y, int pre[],graph g1[])
{
int root1, root2;
root1 = find(x, pre);
root2 = find(y, pre);
if(root1 == root2)
g1[root1].ring = true;
else
{
if(g1[root1].son >= g1[root2].son)
{
pre[root2] = root1;
g1[root1].son += g1[root2].son;
}
else
{
pre[root1] = root2;
g1[root2].son += g1[root1].son;
}
}
}
bool cmp(int num, graph g1[], graph g2[])
{
sort(g1 + 1, g1 + num + 1, cmb);
sort(g2 + 1, g2 + num + 1, cmb);
for(int i = 1; i <= num; ++i)
if(g1[i].son != g2[i].son || (g1[i].son == g2[i].son && g1[i].ring != g2[i].ring))
return false;
return true;
}
int main()
{
int ncase, T = 0;
int link1, link2;
int hand1, hand2;
int ans1, ans2;
bool flag;
scanf("%d", &ncase);
while(ncase--)
{
flag = true;
scanf("%d%d", &num1, &link1);
for(int i = 1; i < MAXN; ++i)
{
pre1[i] = i;
pre2[i] = i;
g1[i].son = 1;
g2[i].son = 1;
g1[i].ring = false;
g2[i].ring = false;
}
for(int i = 1; i <= link1; ++i)
{
scanf("%d%d", &hand1, &hand2);
join(hand1, hand2, pre1, g1);
}
scanf("%d%d", &num2, &link2);
if(link2 != link1)
flag = false;
for(int i = 1; i <= link2; ++i)
{
scanf("%d%d", &hand1, &hand2);
if(flag == false)
continue;
else
join(hand1, hand2, pre2, g2);
}
flag = cmp(num2, g1, g2);
if(flag == false)
printf("Case #%d: NO\n", ++T);
else
{
if(flag)
printf("Case #%d: YES\n", ++T);
else
printf("Case #%d: NO\n", ++T);
}
}
return 0;
}

115
HDOJ/3927_autoAC.cpp Normal file
View File

@ -0,0 +1,115 @@
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <memory.h>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <iostream>
#define ll long long
using namespace std;
const int N = 200;
int mtx[N][N], n;
int row[N], col[N], dia[2];
map<int, int> M;
int cunt;
void Change(int r1, int c1, int r2, int c2) {
int d = mtx[r1][c1] - mtx[r2][c2];
if (d == 0) return;
int res = 0;
if ((M[row[r1]]--) == 1) res--;
if ((M[col[c1]]--) == 1) res--;
if ((M[row[r2]]--) == 1) res--;
if ((M[col[c2]]--) == 1) res--;
if (r1 == c1 && (M[dia[0]]--) == 1) res--;
if (r1 == n - c1 - 1 && (M[dia[1]]--) == 1) res--;
if (r2 == c2 && (M[dia[0]]--) == 1) res--;
if (r2 == n - c2 - 1 && (M[dia[1]]--) == 1) res--;
swap(mtx[r1][c1], mtx[r2][c2]);
row[r1] -= d; col[c1] -= d; row[r2] += d; col[c2] += d;
if (r1 == c1) dia[0] -= d;
if (r1 == n - c1 - 1) dia[1] -= d;
if (r2 == c2) dia[0] += d;
if (r2 == n - c2 - 1) dia[1] += d;
if ((M[row[r1]]++) == 0) res++;
if ((M[col[c1]]++) == 0) res++;
if ((M[row[r2]]++) == 0) res++;
if ((M[col[c2]]++) == 0) res++;
if (r1 == c1 && (M[dia[0]]++) == 0) res++;
if (r1 == n - c1 - 1 && (M[dia[1]]++) == 0) res++;
if (r2 == c2 && (M[dia[0]]++) == 0) res++;
if (r2 == n - c2 - 1 && (M[dia[1]]++) == 0) res++;
if (res >= 0) {
cunt += res;
return;
}
M[row[r1]]--; M[col[c1]]--; M[row[r2]]--; M[col[c2]]--;
if (r1 == c1) M[dia[0]]--;
if (r1 == n - c1 - 1) M[dia[1]]--;
if (r2 == c2) M[dia[0]]--;
if (r2 == n - c2 - 1) M[dia[1]]--;
swap(mtx[r1][c1], mtx[r2][c2]);
row[r1] += d; col[c1] += d; row[r2] -= d; col[c2] -= d;
if (r1 == c1) dia[0] += d;
if (r1 == n - c1 - 1) dia[1] += d;
if (r2 == c2) dia[0] -= d;
if (r2 == n - c2 - 1) dia[1] -= d;
M[row[r1]]++; M[col[c1]]++; M[row[r2]]++; M[col[c2]]++;
if (r1 == c1) M[dia[0]]++;
if (r1 == n - c1 - 1) M[dia[1]]++;
if (r2 == c2) M[dia[0]]++;
if (r2 == n - c2 - 1) M[dia[1]]++;
}
int main() {
int T, C, m, idx, s1, s2;
int r1, c1, r2, c2;
scanf("%d", &T);
for (C = 1; C <= T; C++) {
scanf("%d", &n);
idx = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
mtx[i][j] = ++idx;
M.clear();
cunt = 0;
for (int i = 0; i < n; i++) {
s1 = 0, s2 = 0;
for (int j = 0; j < n; j++) {
s1 += mtx[i][j];
s2 += mtx[j][i];
}
row[i] = s1; col[i] = s2;
if ((M[s1]++) == 0) cunt++;
if ((M[s2]++) == 0) cunt++;
}
s1 = s2 = 0;
for (int i = 0; i < n; i++) {
s1 += mtx[i][i];
s2 += mtx[i][n-i-1];
}
dia[0] = s1; dia[1] = s2;
if ((M[s1]++) == 0) cunt++;
if ((M[s2]++) == 0) cunt++;
m = 2 * n + 2;
while (cunt < m) {
r1 = rand() % n;
r2 = rand() % n;
c1 = rand() % n;
c2 = rand() % n;
Change(r1, c1, r2, c2);
}
printf("Case #%d:\n", C);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j) printf(" ");
printf("%d", mtx[i][j]);
}
printf("\n");
}
}
return 0;
}

55
HDOJ/3928_autoAC.cpp Normal file
View File

@ -0,0 +1,55 @@
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <functional>
#define Maxn 100
#define inf 1<<30
using namespace std;
int T, n, f[Maxn][Maxn], out[Maxn][Maxn];
int le[Maxn], ri[Maxn];
int dfs(int x, int y)
{
if (f[x][y] != -1) return f[x][y];
if (out[x][y] == 1) return f[x][y] = 0;
int t1, t2, t3, tmp = inf;
for (int i=1; i<=n; i++)
{
t1 = t2 = t3 = -inf;
int x1 = x, yy1 = min(le[i]-1, y);
if (yy1 == y) continue;
if (x1 <= yy1 && out[x1][yy1]) t1 = dfs(x1, yy1);
int x2 = max(le[i]+1, x), y2 = min(ri[i]-1, y);
if (x2 == x && y2 == y) continue;
if (x2 <= y2 && out[x2][y2]) t2 = dfs(x2, y2);
int x3 = max(ri[i], x), y3 = y;
if (x3 == x) continue;
if (x3 <= y3 && out[x3][y3]) t3 = dfs(x3, y3);
tmp = min(tmp, max(t1,max(t2, t3)));
}
return f[x][y] = tmp + 1;
}
int main()
{
int k;
scanf("%d", &T);
for (int t=1; t<=T; t++)
{
memset(le, -1, sizeof(le));
memset(f, -1, sizeof(f));
memset(out, 0, sizeof(out));
scanf("%d", &n);
for (int i=1; i<=2*n; i++)
{
scanf("%d", &k);
if (le[k] == -1) le[k] = i;
else ri[k] = i;
}
for (int i=1; i<=2*n; i++)
for (int j=i; j<=2*n; j++)
for (int p=1; p<=n; p++)
if (ri[p] <= j && ri[p] >= i) out[i][j]++;
printf("Case #%d: %d\n", t, dfs(2, 2*n));
}
return 0;
}

34
HDOJ/3929_autoAC.cpp Normal file
View File

@ -0,0 +1,34 @@
#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
typedef long long LL;
const int N=20;
LL w[N];
LL ans,n;
LL get(LL x)
{
return x==0? 0:get(x-(x&-x))+1;
}
void dfs(LL beg,LL num,LL sym)
{
ans+=((LL)1<<get(num))*sym;
for(LL i=beg+1;i<=n;i++)
dfs(i,num&w[i],-2*sym);
}
int main()
{
LL k=1,t,i;
cin>>t;
while(t--)
{
cin>>n;
for(i=1;i<=n;i++)
cin>>w[i];
ans=0;
for(i=1;i<=n;i++)
dfs(i,w[i],1);
cout<<"Case #"<<k++<<": "<<ans<<endl;
}
return 0;
}

179
HDOJ/3930_autoAC.cpp Normal file
View File

@ -0,0 +1,179 @@
#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#include <map>
using namespace std;
typedef long long LL;
const int N=1000005;
int p[N];
bool prime[N];
int num,cnt;
LL k,m,newx,g;
LL a[65],b[65];
void isprime()
{
num=0;
int i,j;
memset(prime,true,sizeof(prime));
for(i=2;i<N;i++)
{
if(prime[i])
{
p[num++]=i;
for(j=i+i;j<N;j+=i)
{
prime[j]=false;
}
}
}
}
LL multi(LL a,LL b,LL m)
{
LL ans=0;
while(b)
{
if(b&1)
{
ans=(ans+a)%m;
b--;
}
b>>=1;
a=(a+a)%m;
}
return ans;
}
LL quick_mod(LL a,LL b,LL m)
{
LL ans=1;
a%=m;
while(b)
{
if(b&1)
{
ans=multi(ans,a,m);
b--;
}
b>>=1;
a=multi(a,a,m);
}
return ans;
}
void factor(LL n)
{
cnt=0;
for(int i=0;(LL)p[i]*p[i]<=n;i++)
{
if(n%p[i]==0)
{
a[cnt]=p[i];
int c=0;
while(n%p[i]==0)
{
c++;
n/=p[i];
}
b[cnt++]=c;
}
}
if(n>1)
{
a[cnt]=n;
b[cnt++]=1;
}
}
LL extend_Euclid(LL a,LL b,LL &x,LL &y)
{
if(b==0)
{
x=1;
y=0;
return a;
}
LL gd=extend_Euclid(b,a%b,x,y);
LL temp=x;
x=y;
y=temp-(a/b)*y;
return gd;
}
LL Inv(LL n,LL p)
{
return quick_mod(n,p-2,p);
}
bool dfs(int dept,LL t)
{
if(dept==cnt)
{
LL ans=quick_mod(g,t,m);
if(ans==1&&t!=m-1) return false;
return true;
}
LL tmp=1;
for(int i=0;i<=b[dept];i++)
{
if(!dfs(dept+1,t*tmp)) return false;
tmp*=a[dept];
}
return true;
}
void find()
{
factor(m-1);
for(g=2;;g++)
if(dfs(0,1)) break;
}
LL log_x(LL a,LL b,LL p)
{
map<LL,int>x;
LL z=(LL)ceil(sqrt(p*1.0));
LL v=Inv(quick_mod(a,z,p),p);
LL e=1;
x[1]=0;
for(int i=1;i<z;i++)
{
e=multi(e,a,p);
if(!x.count(e))
x[e]=i;
}
for(int i=0;i<z;i++)
{
if(x.count(b))
return i*z+x[b];
b=multi(b,v,p);
}
return -1;
}
LL sol[1005];
void Solve(LL a,LL b,LL n)
{
LL d,x,y;
d=extend_Euclid(a,n,x,y);
if(b%d) puts("-1");
else
{
n/=d;b/=d;
sol[0]=(x*b%n+n)%n;
for(int i=1;i<d;i++)
sol[i]=sol[i-1]+n;
for(int i=0;i<d;i++)
sol[i]=quick_mod(g,sol[i],m);
sort(sol,sol+d);
for(int i=0;i<d;i++)
cout<<sol[i]<<endl;
}
}
int main()
{
int t=1;
isprime();
while(cin>>k>>m>>newx)
{
find();
LL t1=log_x(g,newx,m);
LL t2=m-1;
cout<<"case"<<t++<<":"<<endl;
Solve(k,t1,t2);
}
return 0;
}

115
HDOJ/3931_autoAC.cpp Normal file
View File

@ -0,0 +1,115 @@
#include <cstdio>
#include <cstring>
const int maxN=255;
const int maxn=550;
const int inf=1<<25;
const int s=0;
int L , W , N , P;
struct edge{
int v,next,w;
}edge[maxn*maxn];
int head[maxn],cnt;//for sap
void addedge(int u, int v, int w)
{
edge[cnt].v=v;
edge[cnt].w=w;
edge[cnt].next=head[u];
head[u]=cnt++;
edge[cnt].v=u;
edge[cnt].w=0;
edge[cnt].next=head[v];
head[v]=cnt++;
}
int sap(int t)
{
int pre[maxn],cur[maxn],dis[maxn],gap[maxn];
int flow=0 , aug=inf ,u;
bool flag;
for (int i=0 ; i<=t ; ++i)
{
cur[i]=head[i];
gap[i]=dis[i]=0;
}
gap[s]=t+1;
u=pre[s]=s;
while (dis[s]<=t)
{
flag=0 ;
for (int &j=cur[u] ; ~j ; j=edge[j].next)
{
int v=edge[j].v;
if (edge[j].w>0 && dis[u]==dis[v]+1)
{
flag=1;
if(edge[j].w<aug)aug=edge[j].w;
pre[v]=u;
u=v;
if (u==t)
{
flow+=aug;
while (u!=s)
{
u=pre[u];
edge[cur[u]].w-=aug;
edge[cur[u]^1].w+=aug;
}
aug=inf;
}
break;
}
}
if (flag)continue ;
int mindis=t+1;
for (int j=head[u]; ~j ; j=edge[j].next)
{
int v=edge[j].v;
if (edge[j].w>0 && dis[v]<mindis)
{
mindis=dis[v];
cur[u]=j;
}
}
if(--gap[dis[u]]==0)break;
gap[dis[u]=mindis+1]++;
u=pre[u];
}
return flow;
}
int x[maxN],y[maxN],r[maxN],p[maxN];//for build graph
bool intersect (int a,int b)
{
int dis=(x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]);
if(dis<=((r[a]+r[b])*(r[a]+r[b])))return true ;
else return false ;
}
void build_graph()
{
int n=2*N;
for (int i=1 ; i<=N ; ++i)
{
addedge (i,i+N,p[i]);
if(y[i]<=r[i])addedge(0,i,inf);
if(y[i]+r[i]>=W)addedge(i+N,n+1,inf);
for (int j=i+1 ; j<=N ; ++j)//
if(intersect(i,j))addedge(i+N,j,inf),addedge(j+N,i,inf);
}
}
void init ()
{
memset (head , -1 , sizeof(head));
cnt=0;
}
int main ()
{
while (~scanf("%d%d%d%d",&L,&W,&N,&P))
{
init();
for (int i=1 ; i<=N ; ++i)
scanf("%d %d %d %d",x+i,y+i,r+i,p+i);
build_graph();
int ans=P-sap(2*N+1);
if(ans<0)printf("Our hero has been killed\n");
else printf("%d\n",ans);
}
return 0;
}

65
HDOJ/3932_autoAC.cpp Normal file
View File

@ -0,0 +1,65 @@
#include <cstdio>
#include <cmath>
#include <time.h>
#include <cstdlib>
using namespace std;
const double pi=acos(-1.0);
const int maxn=1005;
double x[maxn], y[maxn];
int n;
double dis2 (double x1,double y1 ,double x2,double y2)
{
double tmp1=x1-x2,tmp2=y1-y2;
tmp1*=tmp1;
tmp2*=tmp2;
return tmp1+tmp2;
}
double test(double xx, double yy)
{
double max = 0,tmp;
for (int i=0;i<n;i++)
if(max<(tmp=dis2(xx,yy,x[i],y[i])))max=tmp;
return max;
}
int main()
{
double xx,yy;
double delta,theta;
double X,Y;
double retx,rety,ans;
while (~scanf("%lf%lf%d",&X,&Y,&n))
{
for (int i=0 ; i<n ; i++)
scanf("%lf%lf",x+i,y+i);
double ans=1000000000.0;
for (int i=0 ; i<10 ; ++i)
{
xx=((double)(rand()%1001)/1000.0)*X;
yy=((double)(rand()%1001)/1000.0)*Y;
double dis=test(xx,yy);
for (delta=X ; delta>0.001 ; delta*=0.9)
{
for (theta=0 ; theta<=2*pi ; theta+=(pi/25.0))
{
double tx=xx+delta*cos(theta);
double ty=yy+delta*sin(theta);
double tdis=test(tx,ty);
if(tdis<dis)
{
xx=tx;
yy=ty;
dis=tdis;
}
}
}
if(dis<ans)
{
retx=xx;
rety=yy;
ans=dis;
}
}
printf("(%.1lf,%.1lf).\n%.1lf\n",retx,rety,sqrt(ans));
}
return 0;
}

40
HDOJ/3933_autoAC.cpp Normal file
View File

@ -0,0 +1,40 @@
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cctype>
using namespace std;
const int maxn=1001;
const int maxs=101;
int dp[maxs][maxn];
int data[maxn];
int min(int a,int b){
return a<b?a:b;
}
int main(){
int n,s,la,lb;
while(scanf("%d",&n)&&n){
scanf("%d%d%d",&lb,&la,&s);
memset(dp,0,sizeof(dp));
int i,j,k;
for(i=1;i<=n;i++){
scanf("%d",&data[i]);
dp[0][i]=data[i];
dp[0][i]+=dp[0][i-1];
}
for(i=1;i<=s;i++){
for(j=1;j<=n;j++){
dp[i][j]=dp[i][j-1]+data[j];
for(k=la;k<=lb && k<=j;k++){
dp[i][j]=min(dp[i][j],dp[i-1][j-k]);
}
}
}
int ans=1<<30;
for(i=0;i<=s;i++){
ans=min(dp[s][n],ans);
}
printf("%d\n",ans);
}
return 0;
}

82
HDOJ/3934_autoAC.cpp Normal file
View File

@ -0,0 +1,82 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
#define PR 1e-8
#define N 50015
struct TPoint
{
double x,y;
TPoint(){}
TPoint(double _x,double _y):x(_x),y(_y){}
TPoint operator-(const TPoint p) {return TPoint(x-p.x,y-p.y);}
}ply[N];
int n;
double MAX(double a,double b) {return a>b?a:b;}
double dist(TPoint a,TPoint b)
{
TPoint c(b-a);
return sqrt(c.x*c.x+c.y*c.y);
}
double cross(TPoint a,TPoint b,TPoint c)
{
TPoint s(b-a),t(c-a);
return s.x*t.y-s.y*t.x;
}
int dblcmp(double a)
{
if(fabs(a)<PR) return 0;
return a>0?1:-1;
}
bool cmpx(TPoint a,TPoint b)
{
if(fabs(a.x-b.x)<PR) return a.y<b.y;
return a.x<b.x;
}
bool cmp(TPoint a,TPoint b)
{
int d1=dblcmp(cross(ply[0],a,b));
return d1>0||(d1==0&&dist(ply[0],a)<dist(ply[0],b));
}
double diss(TPoint a,TPoint b)
{
return dist(a,b)*dist(a,b);
}
int main()
{
while(~scanf("%d",&n))
{
int i,top=2,j,p,q,r;
for(i=0;i<n;i++)
scanf("%lf%lf",&ply[i].x,&ply[i].y);
sort(ply,ply+n,cmpx);
sort(ply+1,ply+n,cmp);
for(i=2;i<n;i++)
{
while(top>1&&(dblcmp(cross(ply[top-2],ply[i],ply[top-1])))>=0) top--;
ply[top++]=ply[i];
}
double max1=-1e20,tmp;
n=top; ply[n]=ply[0]; ply[n+1]=ply[1]; ply[n+2]=ply[2];
p=0; q=1; r=2;
while(1)
{
int pp=p,qq=q,rr=r;
while(cross(ply[p],ply[q],ply[r+1])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
r=(r+1)%n;
max1=MAX(max1,fabs(tmp)*0.5);
while(cross(ply[p],ply[q+1],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
q=(q+1)%n;
max1=MAX(max1,fabs(tmp)*0.5);
while(cross(ply[p+1],ply[q],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
p=(p+1)%n;
max1=MAX(max1,fabs(tmp)*0.5);
if(pp==p&&qq==q&&rr==r) r=(r+1)%n;
if(r==0) break;
}
if(n<3) max1=0;
printf("%.2lf\n",max1);
}
return 0;
}

64
HDOJ/3935_autoAC.cpp Normal file
View File

@ -0,0 +1,64 @@
#include <cstdio>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define maxn 105
int g[maxn];
int x[maxn];
int n,m;
int inf=100*100;
int all;
int Get(int n)
{
n=(n&0x55555555)+((n>>1)&0x55555555);
n=(n&0x33333333)+((n>>2)&0x33333333);
n=(n&0x0f0f0f0f)+((n>>4)&0x0f0f0f0f);
n=(n&0x00ff00ff)+((n>>8)&0x00ff00ff);
n=(n&0x0000ffff)+((n>>16)&0x0000ffff);
return n;
}
void heng(int &x,int i)
{
x^=i;x^=i<<1;x^=i>>1;
x=x&all;
}
int main()
{
int i, j,k;
while(scanf("%d%d", &n,&m) != EOF)
{
memset(g,0,sizeof(g));
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
int tmp;
scanf("%d",&tmp);
g[i]=g[i]<<1|tmp;
}
}
all=(1<<m)-1;
int ans=inf;
for(i=0;i<(1<<m);i++)
{
for(k=0;k<n;k++)x[k]=g[k];
int t=Get(i);
heng(x[0],i);
x[1]^=i;
for(j=1;j<n;j++)
{
int k=x[j-1]^all;
heng(x[j],k);
x[j+1]^=k;
t+=Get(k);
}
if(t<ans&&x[n-1]==all)ans=t;
}
if(ans==inf)printf("no solution\n");
else printf("%d\n",ans);
}
return 0;
}

58
HDOJ/3936_autoAC.cpp Normal file
View File

@ -0,0 +1,58 @@
#include <cstdio>
#include <cstring>
typedef long long ll;
const ll mod=1000000007;
ll mtrx[60][2][2];
void pre_pro()
{
memset (mtrx , 0 , sizeof(mtrx));
mtrx[0][0][0]=1;mtrx[0][0][1]=1;
mtrx[0][1][0]=1;mtrx[0][1][1]=0;
for (int t=0 ; t<60 ; ++t)
for (int i=0 ; i<2 ; ++i)
for (int j=0 ; j<2 ; ++j)
{
for (int k=0 ; k<2 ; ++k)
mtrx[t+1][i][j]+=mtrx[t][i][k]*mtrx[t][k][j];
mtrx[t+1][i][j]%=mod;
}
}
ll fib (ll a)
{
a--;
ll mat[2][2]={1,0,0,1};
ll tmp[2][2];
for (int p=0 ; a ; a>>=1 , ++p)
{
if(!(a&1))continue;
tmp[0][0]=mat[0][0];tmp[0][1]=mat[0][1];
tmp[1][0]=mat[1][0];tmp[1][1]=mat[1][1];
memset (mat, 0 , sizeof(mat));
for (int i=0 ; i<2 ; ++i)
for (int j=0 ; j<2 ; ++j)
{
for (int k=0 ; k<2 ; ++k)
mat[i][j]+=mtrx[p][i][k]*tmp[k][j];
mat[i][j]%=mod;
}
}
return mat[0][0];
}
ll sum(ll a)
{
if(a==0)return 0;
else return fib(2*a)*fib(2*a+1)%mod;
}
int main ()
{
pre_pro();
int cas;
scanf("%d",&cas);
while (cas--)
{
ll l,r;
scanf("%I64d%I64d",&l,&r);
printf("%d\n",(sum(r)-sum(l-1)+mod)%mod);
}
return 0;
}

107
HDOJ/3937_autoAC.cpp Normal file
View File

@ -0,0 +1,107 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<cmath>
#define N 64
struct trie{
int next[N];
int tag;
}data[3000000];
int inp;
int init(int a){
memset(data[a].next,0,sizeof(data[a].next));
data[a].tag=0;
return a;
}
int tran(char a){
if(a>='A'&&a<='Z') return a-'A';
if(a>='a'&&a<='z') return a-'a'+26;
return a-'0'+52;
}
void insert(char *a){
int p=0;
for(;*a;a++){
int d=tran(*a);
if(data[p].next[d]==0)data[p].next[d]=init(++inp);
p=data[p].next[d];
data[p].tag++;
}
}
int query(char *a){
int p=data[0].next[tran(*a)];
for(a++;*a&&p;a++){
int d=tran(*a);
p=data[p].next[d];
}
return data[p].tag;
}
bool isok(double x,double y){
return (fabs(x-y)/x)<0.11;
}
int getint(char *a){
int ret=0;
for(int i=0;i<8;i++)
ret=ret*2+a[i];
return ret;
}
char be[]="begin";
char en[]="end";
bool cmp(char *a,char *b,int len){
for(int i=0;i<len;i++)
if(a[i]!=b[i])
return false;
return true;
}
int T,n,m,tf;
double a,b;
char str[100],ss[10];
int main(void){
while(scanf("%d%d",&T,&m)+1){
inp=0;init(0);
tf=0;
for(int i=0;i<T;i++){
scanf("%s",str);
insert(str);
}
for(;m;m--){
tf=0;
double temp;
scanf("%d",&n);
scanf("%lf%lf",&a,&b);
if(!(a<b&&isok(2*a,b))){
tf=1;
}
ss[0]=0,ss[1]=1;
for(int i=2;i<8;i++){
scanf("%lf",&temp);
if(isok(temp,a))
ss[i]=0;
else
ss[i]=1;
}
str[0]=getint(ss);
for(int i=1;i<n;i++){
for(int j=0;j<8;j++){
scanf("%lf",&temp);
if(isok(temp,a)){
ss[j]=0;
}
else{
ss[j]=1;
}
}
str[i]=getint(ss);
}
str[n]='\0';
if(!cmp(be,str,5)||!cmp(en,str+n-3,3))
tf=1;
if(tf){
printf("wrong barcode!\n");
}
else{
str[n-3]='\0';
printf("%d\n",query(str+5));
}
}
}
}

103
HDOJ/3938_autoAC.cpp Normal file
View File

@ -0,0 +1,103 @@
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define INF 2000000000
#define MAXN 10005
#define L(x) x<<1
#define R(x) x<<1|1
using namespace std;
int n, m, q;
int father[MAXN], num[MAXN];
long long out[MAXN];
struct node
{
int u, v, w;
bool operator <(const node &a)const
{
return w < a.w;
}
}edge[MAXN * 10];
struct wen
{
int l, id;
bool operator <(const wen &a)const
{
return l < a.l;
}
}p[MAXN];
void init()
{
for(int i = 1; i <= n; i++)
{
father[i] = i;
num[i] = 1;
}
}
int find(int x)
{
if(father[x] == x) return x;
int t = find(father[x]);
father[x] = t;
return t;
}
int join(int x, int y)
{
int fx = find(x);
int fy = find(y);
if(fx == fy) return 0;
int t = num[fx] * num[fy];
num[fx] += num[fy];
num[fy] = 0;
father[fy] = fx;
return t;
}
int main()
{
while(scanf("%d%d%d", &n, &m, &q) != EOF)
{
init();
for(int i = 1; i <= m; i++)
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
sort(edge + 1, edge + m + 1);
for(int i = 1; i <= q; i++)
{
scanf("%d", &p[i].l);
p[i].id = i;
}
sort(p + 1, p + q + 1);
int pos = 1;
long long ans = 0;
for(int i = 1; i <= q; i++)
{
while(pos <= m && edge[pos].w <= p[i].l)
{
ans += join(edge[pos].u, edge[pos].v);
pos ++;
}
out[p[i].id] = ans;
}
for(int i = 1; i <= q; i++)
printf("%I64d\n", out[i]);
}
return 0;
}

85
HDOJ/3939_autoAC.cpp Normal file
View File

@ -0,0 +1,85 @@
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
#define maxn 1000010
int phi[maxn];
int prime[maxn],cnt;
bool flag[maxn];
int p[100],num;
LL ans,l;
void init()
{
cnt=0;
memset(flag,0,sizeof(flag));
for(int i=2;i<maxn;i++)
if(!flag[i])
{
prime[cnt++]=i;
for(int j=i+i;j<maxn;j+=i)
flag[j]=1;
}
for(int i=0;i<maxn;i++) phi[i]=i;
for(int i=2;i<maxn;i+=2) phi[i]>>=1;
for(int i=3;i<maxn;i+=2)
if(phi[i]==i)
for(int j=i;j<maxn;j+=i)
phi[j]=phi[j]-phi[j]/i;
}
void divide(int x)
{
num=0;
for(int i=0;i<cnt&&prime[i]*prime[i]<=x;i++)
if(x%prime[i]==0)
{
p[num++]=prime[i];
while(x%prime[i]==0) x/=prime[i];
}
if(x>1) p[num++]=x;
}
void dfs(int id,int mul,int tot,int x)
{
if(id==num)
{
if(tot&1) ans=ans-x/mul;
else ans=ans+x/mul;
return ;
}
dfs(id+1,mul*p[id],tot+1,x);
dfs(id+1,mul,tot,x);
}
int main()
{
init();
int t;
cin>>t;
while(t--)
{
scanf("%lld",&l);
int temp=sqrt(l+0.0);
ans=0;
for(int i=1;i<=temp;i++)
{
int lim=sqrt(l-(LL)i*i+0.0);
if(i&1)
{
divide(i);
if(i<=lim) dfs(0,1,0,i>>1);
else dfs(0,1,0,lim>>1);
}
else
{
if(i<=lim) ans+=phi[i];
else
{
divide(i);
dfs(0,1,0,lim);
}
}
}
printf("%lld\n",ans);
}
return 0;
}

52
HDOJ/3940_autoAC.cpp Normal file
View File

@ -0,0 +1,52 @@
#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
double fly_pos(double vx,double vy,double h)
{
return vx*(vy+sqrt(vy*vy+19.6*h))/9.8;
}
double fly_h(double vy,double h,double t)
{
return h+vy*t-4.9*t*t;
}
int main()
{
double h,vx,vy,t,h0,l,v1,v2,v3;
char bird[10];
while(~scanf("%lf%s",&h,bird))
{
if(!strcmp("Red",bird))
{
scanf("%lf%lf",&vx,&vy);
printf("%.3lf\n",fly_pos(vx,vy,h));
}
else if(!strcmp("Blue",bird))
{
scanf("%lf%lf%lf%lf%lf%lf",&vx,&vy,&t,&v1,&v2,&v3);
if(fly_pos(vx,vy,h)<t*vx)
{
printf("%.3lf\n",fly_pos(vx,vy,h));
continue;
}
h0=fly_h(vy,h,t);
l=vx*t;
vy=vy-9.8*t;
printf("%.3lf %.3lf %.3lf\n",l+fly_pos(v1,vy,h0),l+fly_pos(v2,vy,h0),l+fly_pos(v3,vy,h0));
}
else
{
scanf("%lf%lf%lf",&vx,&vy,&t);
if(fly_pos(vx,vy,h)<t*vx)
{
printf("%.3lf\n",fly_pos(vx,vy,h));
continue;
}
h0=fly_h(vy,h,t);
l=vx*t;
vy=vy-9.8*t;
printf("%.3lf\n",l+fly_pos(2*vx,2*vy,h0));
}
}
return 0;
}

77
HDOJ/3941_autoAC.cpp Normal file
View File

@ -0,0 +1,77 @@
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <cstring>
#include <string>
#include <map>
#include <set>
#include <vector>
using namespace std;
const int MOD=1000000007;
const int MaxN=103;
const int MaxM=203;
int N,K,f[2][MaxN][MaxM],s[MaxN][MaxM];
int solve()
{
int MaxK=2*K+1;
for (int i=0; i<=K; ++i)
for (int j=0; j<=MaxK; ++j) f[0][i][j]=s[i][j]=0;
f[0][0][0]=1;
s[0][0]=1;
int cur=0,last;
for (int i=1; i<=N; ++i)
{
last=cur;
cur=1-cur;
for (int j=0; j<=K; ++j)
for (int k=0; k<=MaxK; ++k) f[cur][j][k]=0;
f[cur][0][0]=1;
for (int j=1; j<=K; ++j)
{
for (int k=j; k<MaxK-1; ++k)
{
f[cur][j][k]=f[cur][j-1][k-1]+f[last][j][k-j];
f[cur][j][k]%=MOD;
}
for (int p=0; p<=j; ++p)
{
int cnt=MaxK-1-j;
f[cur][j][MaxK-1]+=s[p][cnt];
f[cur][j][MaxK-1]%=MOD;
cnt=MaxK-j;
f[cur][j][MaxK]+=s[p][cnt];
f[cur][j][MaxK]%=MOD;
}
}
for (int j=0; j<=K; ++j)
for (int k=MaxK; k>=0; --k) s[j][k]=f[cur][j][k];
for (int j=0; j<=K; ++j)
for (int k=MaxK-2; k>=0; --k)
{
s[j][k]+=s[j][k+2];
s[j][k]%=MOD;
}
}
int ans=0;
for (int i=0; i<=K; ++i)
for (int j=i+i; j<MaxK; j+=2)
{
ans+=f[cur][i][j];
ans%=MOD;
}
return ans;
}
int main()
{
int Testnum;
scanf("%d",&Testnum);
for (int Test=1; Test<=Testnum; ++Test)
{
scanf("%d %d",&N,&K);
printf("Case #%d: %d\n",Test,solve());
}
}

76
HDOJ/3943_autoAC.cpp Normal file
View File

@ -0,0 +1,76 @@
#include"cstdlib"
#include"cstdio"
#include"cstring"
#include"cmath"
#include"queue"
#include"algorithm"
#include"iostream"
using namespace std;
__int64 dp[22][22][22];
int num[22];
__int64 dfs(int site,int a,int b,int f,int x,int y)
{
if(site==0)
{
if(a==x&&b==y) return 1;
return 0;
}
if(!f&&dp[site][a][b]!=-1) return dp[site][a][b];
int len=f?num[site]:9;
__int64 ans=0;
for(int i=0;i<=len;i++)
{
if(i==4) ans+=dfs(site-1,a+1,b,f&&i==len,x,y);
else if(i==7) ans+=dfs(site-1,a,b+1,f&&i==len,x,y);
else ans+=dfs(site-1,a,b,f&&i==len,x,y);
}
if(!f) dp[site][a][b]=ans;
return ans;
}
__int64 solve(__int64 a,int x,int y)
{
int cnt=0;
while(a)
{
num[++cnt]=a%10;
a/=10;
}
return dfs(cnt,0,0,1,x,y);
}
int main()
{
int t,cas=1;
cin>>t;
while(t--)
{
__int64 p,q;
int x,y;
scanf("%I64d%I64d%d%d",&p,&q,&x,&y);
memset(dp,-1,sizeof(dp));
int n;
scanf("%d",&n);
printf("Case #%d:\n",cas++);
while(n--)
{
__int64 k,s;
__int64 ans=-1;
s=solve(p,x,y);
scanf("%I64d",&k);
s+=k;
__int64 l=p+1,r=q;
while(l<=r)
{
__int64 mid=(l+r)/2;
if(solve(mid,x,y)>=s)
{
ans=mid;
r=mid-1;
}
else l=mid+1;
}
if(ans!=-1) printf("%I64d\n",ans);
else puts("Nya!");
}
}
return 0;
}

69
HDOJ/3944_autoAC.cpp Normal file
View File

@ -0,0 +1,69 @@
#include <cstdio>
#include <cstring>
#include <vector>
#define maxn 10000
using namespace std;
int flag[maxn],pim[maxn],tol;
int p[1229][9973];
int ni[1229][9973];
int mp[10000];
void init()
{
tol=0;
for(int i=2; i<maxn; i++)
{
if(!flag[i]) pim[tol++]=i;
for(int j=0; j<tol&&i*pim[j]<maxn; j++)
{
flag[i*pim[j]]=1;
if(i%pim[j]==0) break;
}
}
for(int i=0; i<tol; i++)
{
int k=pim[i];
mp[k]=i;
p[i][0]=1, p[i][1]=1;
ni[i][0]=1,ni[i][1]=1;
for(int j=2; j<k; j++)
{
p[i][j]=j*p[i][j-1]%pim[i];
ni[i][j]=-k/j*ni[i][k%j]%k;
if(ni[i][j]<0) ni[i][j]+=k;
}
}
for(int i=0; i<tol; i++)
{
int k=pim[i];
for(int j=1; j<k; j++)
{
ni[i][j]=ni[i][j]*ni[i][j-1]%k;
}
}
}
int cal(int n,int m,int v)
{
if(n<m) return 0;
int x=mp[v];
return p[x][n] * ni[x][m]%v * ni[x][n-m]%v;
}
int main()
{
int n,k,p,ca=0;
init();
while(scanf("%d %d %d",&n,&k,&p)==3)
{
if(k>n/2) k=n-k;
int res=1,u_u=n-k;
n++;
while(n&&k)
{
res=res*cal(n%p,k%p,p)%p;
if(res==0) break;
n/=p;
k/=p;
}
printf("Case #%d: %d\n",++ca,(res+u_u)%p);
}
return 0;
}

129
HDOJ/3945_autoAC.cpp Normal file
View File

@ -0,0 +1,129 @@
#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define mod 1000000009
#define pb push_back
vector <int> p[15];
int st[15];
int f[1<<16][20];
int to[15][20][20];
long long dp[15][25][25];
int num[1<<16];
int dx[]= {0,0,-1,1,1,1,-1,-1};
int dy[]= {-1,1,0,0,1,-1,1,-1};
int check(int x,int y)
{
if(x>=0 && x<4 && y>=0 && y<4)return 1;
return 0;
}
int nxt(int t)
{
int ret=0;
rep(i,17)
{
int x=i/4;
int y=i%4;
int cnt=0;
for(int j=0; j<8; j++)
{
int nx = x+dx[j];
int ny = y+dy[j];
if(check(nx,ny))
{
int pos = nx*4+ny;
if((1<<pos)&t)
cnt++;
}
}
if((1<<i)&t)
{
if(cnt==2||cnt==3)
ret^=(1<<i);
}
else
{
if(cnt==3)
ret^=(1<<i);
}
}
return ret;
}
void init()
{
int n = 1<<16;
memset(num,0,sizeof(num));
rep(i,n)rep(j,17)
if(i&(1<<j))
num[i]++;
rep(i,n)f[i][0]=nxt(i);
for(int i=1; i<=18; i++)
for(int j=0; j<n; j++)
f[j][i]=f[f[j][i-1]][i-1];
}
int getnxt(int s,int t)
{
for(int i=18; i>=0; i--)
if((1<<i)<=t)
{
t-=(1<<i);
s=f[s][i];
}
return s;
}
int main()
{
int L,K,M,T,N,t;
init();
scanf("%d",&L);
rep(cas,L)
{
scanf("%d%d%d%d",&K,&M,&T,&N);
rep(i,K)p[i].clear();
memset(st,0,sizeof(st));
rep(k,K)rep(i,4)rep(j,4)
{
scanf("%d",&t);
if(t)st[k]^=(1<<(i*4+j));
}
int n=1<<16;
memset(to,0,sizeof(to));
rep(k,K) // 10*2^16
rep(i,n)
if((st[k]&i) == st[k])
{
int j=i^st[k];
int cnt1=num[j];
int _nxt=getnxt(i,T);
int cnt2=num[_nxt];
to[k][cnt1][cnt2]++;
}
memset(dp,0,sizeof(dp));
dp[0][0][0]=1;
for(int k=0; k<K; k++)
{
for(int i=0; i<=M; i++)
{
for(int j=0; j<=N; j++)
{
if(dp[k][i][j]==0)continue;
for(int p=0; p<=16; p++)
{
for(int q=0; q<=16; q++)
{
if(to[k][p][q]==0)continue;
if(i+p<=M && j+q<=N)
dp[k+1][i+p][j+q]=(dp[k+1][i+p][j+q]+dp[k][i][j]*to[k][p][q])%mod;
}
}
}
}
}
long long ret=0;
for(int i=0; i<=M; i++)
ret=(ret+dp[K][i][N])%mod;
printf("Case #%d: %I64d\n",cas+1,ret);
}
}

43
HDOJ/3946_autoAC.cpp Normal file
View File

@ -0,0 +1,43 @@
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int a[10005], b[10005];
int res, pre, as[10005];
bool cmp(int x, int y)
{
return x>y;
}
int main()
{
int n, m, an, bn, t=1, ca, i, end, lef, tmp;
scanf("%d", &ca);
while(ca-->0)
{
scanf("%d%d%d%d", &n, &m, &an, &bn);
for(i=0; i<an; i++)
scanf("%d", &a[i]);
for(i=0; i<bn; i++)
scanf("%d", &b[i]);
sort(a, a+an, cmp);
sort(b, b+bn, cmp);
memset(as, 0, sizeof(as));
for(i=1; i<=an; i++)as[i]=as[i-1]+a[i-1];
end=n*m/3;
if(((n==2)&&(m%3==2))||((m==2)&&(n%3==2)))end--;
end=min(end, bn);
res=as[min(n*m/2, an)];
pre=0;
for(i=1; i<=end; i++)
{
pre+=b[i-1];
lef=min((n*m-3*i)/2, an);
tmp=pre+as[lef];
if(tmp>res)res=tmp;
}
printf("Case #%d: %d\n", t++, res);
}
return 0;
}

129
HDOJ/3947_autoAC.cpp Normal file
View File

@ -0,0 +1,129 @@
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
using namespace std;
#define sz 200
#define inf 0x7fffffff
int g[sz][sz];
int s[sz],t[sz],v[sz];
struct node{
int s, t, v, len, nxt;
} e[sz * 40 + 20];
int hd[sz], cnt, pre[sz] , pos[sz], dis[sz], vis[sz];
int sum ;
void insert(int s, int t, int v, int len){
e[cnt].s = s;e[cnt].t = t;e[cnt].v = v;e[cnt].len = len;
e[cnt].nxt = hd[s];hd[s] = cnt++;
e[cnt].s = t;e[cnt].t = s;e[cnt].v = 0;e[cnt].len = -len;
e[cnt].nxt = hd[t];hd[t] = cnt++;
}
bool spfa(int s, int t, int n){
for(int i = 0; i < n; i++){
dis[i]=inf;
vis[i]=0;
pre[i]=-1;
}
queue<int>q;
while(!q.empty())q.pop();
q.push(s);
pre[s] = s;
dis[s] = 0;
while( !q.empty() ){
int u = q.front();
q.pop();
vis[u] = 0;
for(int i = hd[u]; i!=-1; i=e[i].nxt){
int v = e[i].t;
if (e[i].v > 0 && dis[u] + e[i].len < dis[v]){
dis[v] = dis[u] + e[i].len;
pre[v] = u;
pos[v] = i;
if (!vis[v]){
vis[v] = 1;
q.push(v);
}
}
}
}
return pre[t] != -1 && dis[t] < inf;
}
int mcf(int s, int t, int n){
int fw = 0, ct = 0;
while(spfa(s,t,n)){
int v = inf;
for(int i = t; i != s; i = pre[i])
v = min(v, e[pos[i]].v);
fw += v;
ct += dis[t] * v;
for(int i = t; i != s; i = pre[i]){
e[pos[i]].v -= v;
e[pos[i] ^ 1].v += v;
}
}
if(fw != sum)return -1;
return ct;
}
struct node1{
int s,t,v,nxt;
}ne[sz*10];
int nhd[sz],ncnt;
void insert1(int s ,int t,int v){
ne[ncnt].s=s;
ne[ncnt].t=t;
ne[ncnt].v=v;
ne[ncnt].nxt = nhd[s];
nhd[s]=ncnt++;
}
int main(){
int TT;
scanf("%d",&TT);
for(int cas=1;cas<=TT;cas++){
int n;
scanf("%d",&n);
memset(pre,-1,sizeof(pre));
int S=0,T=n+1;
memset(hd,-1,sizeof(hd));
cnt = 0;
memset(g,-1,sizeof(g));
memset(pre,-1,sizeof(pre));
memset(nhd,-1,sizeof(nhd));
ncnt=0;
for(int i=1;i<n;i++){
scanf("%d%d%d",&s[i],&t[i],&v[i]);
g[s[i]][t[i]]=i;
pre[s[i]] = t[i];
insert1(t[i],s[i],v[i]);
}
s[n]=1;
t[n]=n+1;
v[n]=0;
insert1(n+1,1,0);
g[1][1+n]=n+1;
pre[1]=n+1;
sum=0;
for(int i=1;i<=n;i++){
int vv = v[i];
for(int j=nhd[s[i]];j!=-1;j=ne[j].nxt){
vv -= ne[j].v;
insert(i,g[ne[j].t][s[i]],inf,0);
}
if(vv>0){
sum+=vv;
insert(S,i,vv,0);
}
if(vv<0){
insert(i,T,-vv,0);
}
}
int m;
cin>>m;
int ss,tt,li,ci;
for(int i=0;i<m;i++){
scanf("%d%d%d%d",&ss,&tt,&li,&ci);
insert(g[ss][pre[ss]],g[tt][pre[tt]],li,ci);
}
printf("Case #%d: ",cas);
cout<<mcf(S,T,T+1)<<endl;
}
}

122
HDOJ/3948_autoAC.cpp Normal file
View File

@ -0,0 +1,122 @@
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 200100
int dp[MAXN][20];
char r[MAXN];
int sa[MAXN];
int wa[MAXN],wb[MAXN],wv[MAXN],ws[MAXN];
int height[MAXN],rk[MAXN];
int mm[MAXN];
int cas;
inline bool cmp(int *r,int a,int b,int len){
return r[a]==r[b]&&r[a+len]==r[b+len];
}
void SA(int n,int m){
int i,j,p,*x=wa,*y=wb,*t;
for(i=0;i<m;i++)
ws[i]=0;
for(i=0;i<n;i++)
ws[x[i]=r[i]]++;
for(i=1;i<m;i++)
ws[i]+=ws[i-1];
for(i=n-1;i>=0;i--)
sa[--ws[x[i]]]=i;
for(j=p=1;p<n;j<<=1,m=p){
for(p=0,i=n-j;i<n;i++)
y[p++]=i;
for(i=0;i<n;i++){
if(sa[i]>=j)
y[p++]=sa[i]-j;
}
for(i=0;i<m;i++)
ws[i]=0;
for(i=0;i<n;i++)
ws[wv[i]=x[y[i]]]++;
for(i=1;i<m;i++)
ws[i]+=ws[i-1];
for(i=n-1;i>=0;i--)
sa[--ws[wv[i]]]=y[i];
for(t=x,x=y,y=t,x[sa[0]]=0,p=i=1;i<n;i++)
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
}
}
void Height(int n){
int i,j,k=0;
for(i=0;i<=n;i++)
rk[sa[i]]=i;
for(i=0;i<n;height[rk[i++]]=k)
for(k?k--:0,j=sa[rk[i]-1];r[i+k]==r[j+k];k++);
}
int init(){
int i,j,len;
memset(height,0,sizeof(height));
len=strlen(r);
r[len]='$';
for(j=0;j<len;j++)
r[j+len+1]=r[len-1-j];
r[j+len+1]='\0';
return len*2+1;
}
void st(int n){
int i,j,p,q;
for(i=1;i<=n;i++)
dp[i][0]=i;
for(j=1;j<=mm[n];j++)
for(i=1;i+(1<<j)-1<=n;i++){
p=height[dp[i][j-1]];
q=height[dp[i+(1<<(j-1))][j-1]];
if(p>q)
dp[i][j]=dp[i+(1<<(j-1))][j-1];
else
dp[i][j]=dp[i][j-1];
}
}
int RMQ_MIN(int i,int j){
int tem;
if(i>j){
tem=i;
i=j;
j=tem;
}
i++;
int k=mm[(j-i+1)];
return min(height[dp[i][k]],height[dp[j-(1<<k)+1][k]]);
}
void solve(int n){
int i,j,ans=0,pre1=0,pre2=0;
st(n);
for(i=2;i<=n;i++){
pre1=min(pre1,height[i]);
j=RMQ_MIN(i,rk[n-1-sa[i]]);
if(j>pre1){
ans+=j-pre1;
pre1=j;
}
pre2=min(pre2,height[i]);
j=RMQ_MIN(i,rk[n-sa[i]]);
if(j>pre2){
ans+=j-pre2;
pre2=j;
}
}
printf("Case #%d: %d\n",cas,ans);
}
int main(){
int i,j,n,t,T;
mm[0]=-1;
for(i=1;i<MAXN;i++)
mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
scanf("%d",&T);
cas=0;
for(t=1;t<=T;t++){
scanf("%s",r);
n=init();
SA(n+1,130);
Height(n);
cas++;
solve(n);
}
}

64
HDOJ/3949_autoAC.cpp Normal file
View File

@ -0,0 +1,64 @@
#include<cstdio>
#include<algorithm>
#define MAXN 10010
typedef long long LL;
using namespace std;
int n;
LL a[MAXN];
void Gauss() {
int i, j, k, t;
k = 0;
for (i = 60; i >= 0; i--) {
for (j = k; j < n; j++) {
if ((a[j] >> i) & 1)
break;
}
if (j < n) {
swap(a[j], a[k]);
for (t = 0; t < n; t++) {
if (t != k && ((a[t] >> i) & 1))
a[t] ^= a[k];
}
k++;
}
}
sort(a, a + n);
n = unique(a, a + n) - a;
}
LL Cal(int k) {
LL ans;
int i;
ans = i = 0;
if (a[0] == 0) {
if (k == 1)
return 0;
k--;
i++;
}
for (; i < n && k; k >>= 1, i++) {
if (k & 1)
ans ^= a[i];
}
if (i == n && k)
return -1;
return ans;
}
int main() {
int c, ca = 1;
int i, q;
LL k;
scanf("%d", &c);
while (c--) {
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%I64d", &a[i]);
Gauss();
scanf("%d", &q);
printf("Case #%d:\n", ca++);
while (q--) {
scanf("%I64d", &k);
printf("%I64d\n", Cal(k));
}
}
return 0;
}

195
HDOJ/3950_autoAC.cpp Normal file
View File

@ -0,0 +1,195 @@
#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define MID(a,b) (a+((b-a)>>1))
#define INF (1<<30)
const int N=50005;
int n,q,ed[N];
int st_len,ed_len;
struct Segtree
{
set<int> T[N];
int st[N*4],len[N*4];
void PushUp(int ind)
{
if(st[LL(ind)]<st[RR(ind)])
{
st[ind]=st[LL(ind)];
len[ind]=len[LL(ind)];
}
else
{
st[ind]=st[RR(ind)];
len[ind]=len[RR(ind)];
}
}
void build(int lft,int rht,int ind)
{
st[ind]=INF;
if(lft==rht) T[lft].clear();
else
{
int mid=MID(lft,rht);
build(lft,mid,LL(ind));
build(mid+1,rht,RR(ind));
}
}
void updata(int pos,int ist,bool add,int ind,int lft,int rht)
{
if(lft==rht)
{
if(add) T[lft].insert(ist);
else T[lft].erase(ist);
if(T[lft].size()==0) st[ind]=INF;
else
{
len[ind]=lft; st[ind]=*(T[lft].begin());
}
}
else
{
int mid=MID(lft,rht);
if(pos<=mid) updata(pos,ist,add,LL(ind),lft,mid);
else updata(pos,ist,add,RR(ind),mid+1,rht);
PushUp(ind);
}
}
pair<int,int> query(int ist,int ied,int ind,int lft,int rht)
{
if(ist<=lft&&rht<=ied) return make_pair(st[ind],len[ind]);
else
{
int mid=MID(lft,rht);
pair<int,int> tmp1,tmp2; tmp1.first=INF,tmp2.first=INF;
if(ist<=mid) tmp1=query(ist,ied,LL(ind),lft,mid);
if(ied> mid) tmp2=query(ist,ied,RR(ind),mid+1,rht);
if(tmp1.first<tmp2.first) return tmp1;
else return tmp2;
}
}
}seg;
struct BIT
{
int T[N],sum;
void init(){memset(T,0,sizeof(T));sum=0;}
int lowbit(int x){return x&-x;}
void insert(int x,int add)
{
sum+=add;
while(x<N)
{
T[x]+=add; x+=lowbit(x);
}
}
int query(int k)
{
int ind=0;
for(int i=20;i>=0;i--)
{
ind^=(1<<i);
if(ind<N&&k>T[ind]) k-=T[ind];
else ind^=(1<<i);
}
return ind+1;
}
int getsum()
{
return sum;
}
}bit;
int calu(int st,int len,int m,int a,int b)
{
int ed=st+len-1;
return max(ed-m-b+1,st);
}
bool judge(int st1,int st2,int &ilen,int &ist)
{
ist=st1;
if(st1>st2) return false;
ilen=st2-st1+1;
return true;
}
int main()
{
int t,t_cnt=0;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&q);
seg.build(1,n,1); bit.init();
st_len=n,ed_len=n;
printf("Case #%d:\n",++t_cnt);
while(q--)
{
char cmd[5]; scanf("%s",cmd);
if(cmd[0]=='A')
{
int m,a,b; scanf("%d%d%d",&m,&a,&b);
if(st_len>=m)
{
if(st_len==n)
{
ed[1]=m; bit.insert(1,1); st_len=0; ed_len-=m;
printf("%d\n",1);
}
else
{
int tmp=calu(1,st_len,m,a,b);
ed[tmp]=tmp+m-1; bit.insert(tmp,1);
printf("%d\n",tmp);
int len,st;
if(judge(ed[tmp]+1,st_len,len,st)) seg.updata(len,st,1,1,1,n);
st_len=tmp-1;
}
}
else
{
pair<int,int> res=seg.query(m,m+a+b,1,1,n);
if(res.first!=INF)
{
seg.updata(res.second,res.first,0,1,1,n);
int tmp=calu(res.first,res.second,m,a,b);
ed[tmp]=tmp+m-1; bit.insert(tmp,1);
printf("%d\n",tmp);
int len,st;
if(judge(res.first,tmp-1,len,st)) seg.updata(len,st,1,1,1,n);
if(judge(ed[tmp]+1,res.first+res.second-1,len,st)) seg.updata(len,st,1,1,1,n);
}
else
{
if(ed_len<m) puts("-1");
else
{
int tmp=n-ed_len+1;
ed[tmp]=tmp+m-1; ed_len=n-ed[tmp]; bit.insert(tmp,1);
printf("%d\n",tmp);
}
}
}
}
else
{
int k; scanf("%d",&k);
if(k>bit.getsum()||k<=0) continue;
int st=bit.query(k);
int st1=1;
if(k>1) st1=ed[bit.query(k-1)]+1;
int len1=st-st1;
if(len1>0&&st1!=1) seg.updata(len1,st1,0,1,1,n);
int st2=bit.query(k+1)-1,len2;
if(st2>n) len2=0,st2=n;
else len2=st2-ed[st];
if(len2>0&&!(st2==n)) seg.updata(len2,ed[st]+1,0,1,1,n);
if(st1!=1&&st2!=n) seg.updata(st2-st1+1,st1,1,1,1,n);
if(st1==1) st_len=st2-st1+1;
if(st2==n) ed_len=st2-st1+1;
bit.insert(st,-1);
}
}
}
return 0;
}

18
HDOJ/3951_autoAC.cpp Normal file
View File

@ -0,0 +1,18 @@
#include<iostream>
#include<cstdlib>
#include<stdio.h>
using namespace std;
int main()
{
int t,n,k;
int count=1;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&k);
printf("Case %d: ",count++);
if(k==1&&(n%2==1)) puts("first");
else if(n<=k) puts("first");
else puts("second");
}
}

104
HDOJ/3952_autoAC.cpp Normal file
View File

@ -0,0 +1,104 @@
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
struct Point {
double x, y;
Point operator - (const Point& t) const {
Point tmp;
tmp.x = x - t.x;
tmp.y = y - t.y;
return tmp;
}
Point operator + (const Point& t) const {
Point tmp;
tmp.x = x + t.x;
tmp.y = y + t.y;
return tmp;
}
bool operator == (const Point& t) const {
return fabs(x-t.x) < eps && fabs(y-t.y) < eps;
}
};
struct pol{
Point node[11];
int num;
}P[11];
inline double Cross(Point a, Point b, Point c) {
return (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
bool dotOnSeg(Point p, Point s, Point e) {
if ( p == s || p == e ) // 蜂电规娉
return true;
return Cross(p,s,e) < eps &&
(p.x-s.x)*(p.x-e.x)<eps && (p.y-s.y)*(p.y-e.y)<eps;
}
struct Line {
double a, b, c;
};
Line Turn(Point s, Point e) {
Line ln;
ln.a = s.y - e.y;
ln.b = e.x - s.x;
ln.c = s.x*e.y - e.x*s.y;
return ln;
}
bool Line_Inst(Line l1, Line l2, Point &p) {
double d = l1.a*l2.b - l2.a*l1.b;
if ( fabs(d) < eps ) return false;
p.x = (-l1.c*l2.b + l2.c*l1.b) / d;
p.y = (-l1.a*l2.c + l2.a*l1.c) / d;
return true;
}
int main()
{
int t,i,j,k,cases=1;
scanf("%d",&t);
int x,y,m,n,ans;
while(t--)
{
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d",&P[i].num);
for(j=1;j<=P[i].num;j++)
scanf("%lf%lf",&P[i].node[j].x,&P[i].node[j].y);
}
if(n<=2){ printf("Case %d: %d\n",cases++,n);continue;}
Point p;
int max=0;
for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
for(k=1;k<=P[i].num;k++)
{
for(m=1;m<=P[j].num;m++)
{
ans=2;
Line a=Turn(P[i].node[k],P[j].node[m]) ;
for(x=1;x<=n;x++)
{
if(x==i||x==j) continue;
for(y=1;y<P[x].num;y++)
{
Line b=Turn(P[x].node[y],P[x].node[y+1]);
if(Line_Inst(a,b,p)&&dotOnSeg(p,P[x].node[y],P[x].node[y+1]))
{
ans++;
break;
}
}
}
if(ans>max) max=ans;
}
}
}
}
printf("Case %d: %d\n",cases++,max);
}
return 0;
}

139
HDOJ/3954_autoAC.cpp Normal file
View File

@ -0,0 +1,139 @@
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define MID(a,b) (a+((b-a)>>1))
#define INF (1<<30)
const int N=10000+5;
typedef long long LL;
struct node
{
int lft,rht;
LL level,mx,flag,need;
int mid(){return MID(lft,rht);}
void init(){level=1;mx=0;flag=0;}
void fun(LL valu)
{
mx+=level*valu;
need-=valu;
flag+=valu;
}
};
int n,m,k;
LL ned[12];
struct Segtree
{
node tree[N*4];
void down(int ind)
{
if(tree[ind].flag)
{
tree[LL(ind)].fun(tree[ind].flag);
tree[RR(ind)].fun(tree[ind].flag);
tree[ind].flag=0;
}
}
void up(int ind)
{
tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
tree[ind].level=max(tree[LL(ind)].level,tree[RR(ind)].level);
tree[ind].need=min(tree[LL(ind)].need,tree[RR(ind)].need);
}
void build(int lft,int rht,int ind)
{
tree[ind].lft=lft; tree[ind].rht=rht;
tree[ind].init(); tree[ind].need=ned[2];
if(lft!=rht)
{
int mid=tree[ind].mid();
build(lft,mid,LL(ind));
build(mid+1,rht,RR(ind));
}
}
void updata(int st,int ed,int ind,int valu)
{
int lft=tree[ind].lft,rht=tree[ind].rht;
if(st<=lft&&rht<=ed)
{
if(valu>=tree[ind].need)
{
if(lft==rht)
{
LL &now=tree[ind].level;
tree[ind].mx+=now*valu;
while(tree[ind].mx>=ned[now+1]) now++;
LL tmp=ned[now+1]-tree[ind].mx;
tree[ind].need=tmp/now+(tmp%now!=0);
}
else
{
down(ind);
int mid=tree[ind].mid();
if(st<=mid) updata(st,ed,LL(ind),valu);
if(ed> mid) updata(st,ed,RR(ind),valu);
up(ind);
}
}
else
{
tree[ind].fun(valu);
}
}
else
{
down(ind);
int mid=tree[ind].mid();
if(st<=mid) updata(st,ed,LL(ind),valu);
if(ed> mid) updata(st,ed,RR(ind),valu);
up(ind);
}
}
LL query(int st,int ed,int ind)
{
int lft=tree[ind].lft,rht=tree[ind].rht;
if(st<=lft&&rht<=ed) return tree[ind].mx;
else
{
down(ind);
int mid=tree[ind].mid();
LL mx1=0,mx2=0;
if(st<=mid) mx1=query(st,ed,LL(ind));
if(ed> mid) mx2=query(st,ed,RR(ind));
up(ind);
return max(mx1,mx2);
}
}
}seg;
int main()
{
int t,t_cnt=0;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&n,&k,&m);
ned[1]=0; ned[k+1]=((LL)1<<60);
for(int i=2;i<=k;i++) scanf("%I64d",&ned[i]);
printf("Case %d:\n",++t_cnt);
seg.build(1,n,1);
while(m--)
{
char cmd[5];
int a,b,c;
scanf("%s",cmd);
if(cmd[0]=='W')
{
scanf("%d%d%d",&a,&b,&c);
seg.updata(a,b,1,c);
}
else
{
scanf("%d%d",&a,&b);
printf("%I64d\n",seg.query(a,b,1));
}
}
puts("");
}
return 0;
}

145
HDOJ/3955_autoAC.cpp Normal file
View File

@ -0,0 +1,145 @@
# include<stdio.h>
# include<string.h>
# include<stdlib.h>
# include<queue>
# define N 105
using namespace std;
int n,m,MP;
bool map[N][N][10];
bool visit[N][N];
int x0,y0,endx,endy;
int dir1[6][2]={-1,1, 0,1, 1,1, 1,0, 0,-1, -1,0};
int dir2[6][2]={-1,0, 0,1, 1,0, 1,-1, 0,-1, -1,-1};
struct node{
int x,y;
int sum;
bool operator<(const node &b) const
{
return b.sum < sum;
}
};
int MIN(int a,int b)
{
return a<b?a:b;
}
bool is(int xx,int yy)
{
if(xx<0 || xx>=n || yy<0 || yy>=m) return 0;
return 1;
}
bool is1(int xx,int yy)
{
int i,x1,y1;
if(xx%2==1)
{
for(i=0;i<6;i++)
{
x1=xx+dir1[i][0];
y1=yy+dir1[i][1];
if(is(x1,y1) && map[x1][y1][3]) return 1;
}
return 0;
}
else
{
for(i=0;i<6;i++)
{
x1=xx+dir2[i][0];
y1=yy+dir2[i][1];
if(is(x1,y1) && map[x1][y1][3]) return 1;
}
return 0;
}
}
int bfs()
{
priority_queue<node>q;
node cur,next;
int i,cost,remain;
cur.x=x0;
cur.y=y0;
cur.sum=0;
while(!q.empty()) q.pop();
q.push(cur);
while(!q.empty())
{
cur=q.top();
q.pop();
remain=MP-cur.sum%MP;
if(cur.x==endx && cur.y==endy)
{
if(remain==MP) return cur.sum/MP;
else return cur.sum/MP+1;
}
if(visit[cur.x][cur.y]) continue;
visit[cur.x][cur.y]=1;
for(i=0;i<6;i++)
{
if(cur.x%2==1)
{
next.x=cur.x+dir1[i][0];
next.y=cur.y+dir1[i][1];
}
else
{
next.x=cur.x+dir2[i][0];
next.y=cur.y+dir2[i][1];
}
if(!(is(next.x,next.y)) || map[next.x][next.y][3]) continue;
if(is1(cur.x,cur.y) && is1(next.x,next.y))
{
next.sum=cur.sum+remain;
q.push(next);
}
else if(map[cur.x][cur.y][2] && map[next.x][next.y][2])
{
next.sum=cur.sum+1;
q.push(next);
}
else if(map[cur.x][cur.y][i+4])
{
next.sum=cur.sum+remain;
q.push(next);
}
else
{
if(map[next.x][next.y][0]) cost=1;
else cost=2;
cost *=4;
next.sum=cur.sum+MIN(cost,remain);
q.push(next);
}
}
}
return -1;
}
int main()
{
int i,j,ncase,t,k;
int a[10],ans;
a[0]=1;
for(i=1;i<10;i++)
a[i]=a[i-1]*2;
scanf("%d",&ncase);
for(t=1;t<=ncase;t++)
{
scanf("%d%d%d",&n,&m,&MP);
MP*=4;
memset(map,0,sizeof(map));
for(i=0;i<n;i++)
for(j=0;j<m;j++)
{
scanf("%d",&ans);
for(k=9;k>=0;k--)
if(ans>=a[k])
{
map[i][j][k]=1;
ans-=a[k];
}
}
scanf("%d%d%d%d",&x0,&y0,&endx,&endy);
memset(visit,0,sizeof(visit));
printf("Case %d: %d\n",t,bfs());
}
return 0;
}

151
HDOJ/3957_autoAC.cpp Normal file
View File

@ -0,0 +1,151 @@
# include<stdio.h>
# include<string.h>
# define cc 100
# define rr 60
# define V 6000
int U[V],D[V];
int L[V],R[V];
int C[V],ROW[V];
int H[rr],S[cc];
int mark[rr],visit[27],size,ak;
struct node{
int m;
int num1,num2;
int a[11][2],b[11][2];
}s[27];
void Link(int r,int c)
{
S[c]++;
C[size]=c;
ROW[size]=r;
U[size]=U[c];D[U[c]]=size;
D[size]=c;U[c]=size;
if(H[r]==-1) H[r]=L[size]=R[size]=size;
else
{
L[size]=L[H[r]];R[L[H[r]]]=size;
R[size]=H[r];L[H[r]]=size;
}
size++;
}
void remove(int c)
{
int i;
for(i=D[c];i!=c;i=D[i])
{
L[R[i]]=L[i];
R[L[i]]=R[i];
}
}
void resume(int c)
{
int i;
for(i=U[c];i!=c;i=U[i])
L[R[i]]=R[L[i]]=i;
}
int h()
{
int i,j,k,count=0;
bool hash[cc];
memset(hash,0,sizeof(hash));
for(i=R[0];i;i=R[i])
{
if(hash[i]) continue;
hash[i]=1;
count++;
for(j=D[i];j!=i;j=D[j])
for(k=R[j];k!=j;k=R[k])
hash[C[k]]=1;
}
return count;
}
void Dance(int k)
{
int j,i,c,Min;
if(k+h()>=ak) return;
if(!R[0])
{
if(k<ak) ak=k;
return;
}
for(Min=rr,i=R[0];i;i=R[i])
if(Min>S[i]) Min=S[i],c=i;
for(i=D[c];i!=c;i=D[i])
{
if(visit[mark[ROW[i]]]) continue;
visit[mark[ROW[i]]]=1;
remove(i);
for(j=R[i];j!=i;j=R[j])
remove(j);
Dance(k+1);
for(j=L[i];j!=i;j=L[j])
resume(j);
resume(i);
visit[mark[ROW[i]]]=0;
}
}
int main()
{
int i,j,ncase,t,n,sum[26],number,mob,k,c,r;
scanf("%d",&ncase);
for(t=1;t<=ncase;t++)
{
scanf("%d",&n);
sum[0]=1;
for(i=0;i<n;i++)
{
scanf("%d",&s[i].m);
scanf("%d",&s[i].num1);
for(k=0;k<s[i].num1;k++)
scanf("%d%d",&s[i].a[k][0],&s[i].a[k][1]);
if(s[i].m==2)
{
scanf("%d",&s[i].num2);
for(k=0;k<s[i].num2;k++)
scanf("%d%d",&s[i].b[k][0],&s[i].b[k][1]);
}
sum[i+1]=sum[i]+s[i].m;
}
c=sum[n]-1;
for(i=0;i<=c;i++)
{
S[i]=0;
U[i]=D[i]=i;
L[i+1]=i;R[i]=i+1;
}R[c]=0;
size=c+1;
r=0;
memset(H,-1,sizeof(H));
for(i=0;i<n;i++)
{
r++;
mark[r]=i;
for(j=0;j<s[i].num1;j++)
{
number=s[i].a[j][0];
mob=s[i].a[j][1];
Link(r,sum[number]+mob);
}
for(j=0;j<s[i].m;j++)
Link(r,sum[i]+j);
if(s[i].m==2)
{
r++;
mark[r]=i;
for(j=0;j<s[i].num2;j++)
{
number=s[i].b[j][0];
mob=s[i].b[j][1];
Link(r,sum[number]+mob);
}
for(j=0;j<s[i].m;j++)
Link(r,sum[i]+j);
}
}
memset(visit,0,sizeof(visit));
ak=n;
Dance(0);
printf("Case %d: %d\n",t,ak);
}
return 0;
}

315
HDOJ/3958_autoAC.cpp Normal file
View File

@ -0,0 +1,315 @@
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>
#include <map>
#include <string>
#include <climits>
#include <set>
#include <string>
#include <sstream>
#include <utility>
#include <ctime>
using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::stringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;
using std::random_shuffle;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;
typedef LL TY;
const int MAXN(10010);
const int MAXM(5010);
const int MAXE(10010);
const int MAXK(6);
const int HSIZE(13131);
const int SIGMA_SIZE(26);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);
const int MOD(65521);
template<typename T> void checkmax(T &a, T b){if(b > a) a = b;}
template<typename T> void checkmin(T &a, T b){if(b < a) a = b;}
template<typename T> T ABS(const T &a){return a < 0? -a: a;}
int pre[21][10][MAXN], opt[21][10][MAXN];
int MM;
struct HASH_MAP
{
int first[HSIZE], value[MAXN], next[MAXN];
LL state[MAXN];
int size;
void init()
{
memset(first, -1, sizeof(first));
size = 0;
}
void insert(LL ts, int tv, int x, int y, int pid, int op)
{
int h = ts%HSIZE;
for(int i = first[h]; ~i; i = next[i])
if(state[i] == ts)
{
if(tv > value[i])
{
pre[x][y][i] = pid;
opt[x][y][i] = op;
value[i] = tv;
}
return ;
}
checkmax(MM, size);
pre[x][y][size] = pid;
opt[x][y][size] = op;
state[size] = ts;
value[size] = tv;
next[size] = first[h];
first[h] = size++;
}
} hm[2];
HASH_MAP *cur, *last;
int N, M;
int code[11], path[11];
int Num[8];
char mp[21][15];
void decode(LL ts)
{
for(int i = 0; i <= M; ++i)
{
code[i] = ts&7;
path[i] = ts&8;
ts >>= 4;
}
}
LL encode()
{
LL ret = 0;
memset(Num, -1, sizeof(Num));
int cnt = 0;
for(int i = M; i >= 0; --i)
if(code[i] == 0)
ret = (ret << 4)|path[i];
else
{
if(Num[code[i]] == -1) Num[code[i]] = ++cnt;
ret = (ret << 4)|Num[code[i]]|path[i];
}
return ret;
}
void updata(int x, int y, int tv, int pid)
{
int lc = (y == 0)? 0: code[y];
int uc = (x == 0)? 0: code[y+1];
int lp = (y == 0)? 0: path[y-1];
int up = (x == 0)? 0: path[y+1];
if(mp[x][y] == 'S' || mp[x][y] == 'T')
{
if(lc == 0 && uc == 0)
{
if(lp || up) return;
if(x < N-1)
{
path[y] = 8;
code[y] = 7;
code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
if(y < M-1)
{
path[y] = 8;
code[y] = 0;
code[y+1] = 7;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
}
else
if(lc == 0 || uc == 0)
{
if(lc)
{
if(up) return;
path[y] = 8;
code[y] = code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
else
{
if(lp) return;
path[y] = 8;
code[y] = code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
}
return;
}
if(mp[x][y] == 'B')
{
if(lc == 0 && uc == 0)
{
path[y] = 0;
code[y] = code[y+1] = 0;
cur->insert(encode(), tv, x, y, pid, 0);
}
return;
}
if(lc == 0 && uc == 0)
{
path[y] = 0;
code[y] = code[y+1] = 0;
cur->insert(encode(), tv, x, y, pid, 0);
if(x == N-1 || y == M-1) return;
if(lp || up) return;
path[y] = 8;
code[y] = code[y+1] = 7;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
else
if(lc == 0 || uc == 0)
{
if(lc)
{
if(up) return;
if(x < N-1)
{
path[y] = 8;
code[y] = lc;
code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
if(y < M-1)
{
path[y] = 8;
code[y] = 0;
code[y+1] = lc;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
}
else
{
if(lp) return;
if(x < N-1)
{
path[y] = 8;
code[y] = uc;
code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
if(y < M-1)
{
path[y] = 8;
code[y] = 0;
code[y+1] = uc;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
}
}
else
if(lc != uc)
{
path[y] = 8;
for(int i = 0; i <= M; ++i)
if(code[i] == uc) code[i] = lc;
code[y] = code[y+1] = 0;
cur->insert(encode(), tv+1, x, y, pid, 1);
}
}
void solve()
{
cur = hm;
last = hm+1;
last->init();
last->insert(0, 0, 0, 0, 0, 0);
for(int i = 0; i < N; ++i)
{
int sz = last->size;
for(int j = 0; j < sz; ++j)
last->state[j] <<= 4;
for(int j = 0; j < M; ++j)
{
cur->init();
sz = last->size;
for(int k = 0; k < sz; ++k)
{
decode(last->state[k]);
updata(i, j, last->value[k], k);
}
swap(cur, last);
}
}
int ans = 0, id;
for(int i = 0; i < last->size; ++i)
{
decode(last->state[i]);
bool flag(true);
for(int j = 0; j <= M; ++j)
if(code[j])
{
flag = false;
break;
}
if(flag)
{
if(last->value[i] > ans)
{
ans = last->value[i];
id = i;
}
}
}
for(int i = 0; i < N; ++i)
for(int j = 0; j < M; ++j)
if(mp[i][j] == '.')
mp[i][j] = 'W';
for(int i = N-1; i >= 0; --i)
for(int j = M-1; j >= 0; --j)
{
if(mp[i][j] == 'W' && opt[i][j][id]) mp[i][j] = '.';
id = pre[i][j][id];
}
printf("%d\n", ans);
for(int i = 0; i < N; ++i)
printf("%s\n", mp[i]);
printf("\n");
}
int main()
{
int TC, n_case(0);
scanf("%d", &TC);
while(TC--)
{
scanf("%d%d", &N, &M);
for(int i = 0; i < N; ++i)
scanf("%s", mp[i]);
printf("Case %d: ", ++n_case);
solve();
}
return 0;
}

27
HDOJ/3959_autoAC.cpp Normal file
View File

@ -0,0 +1,27 @@
#include<stdio.h>
long long gcd(long long a,long long b)
{
if(b==0) return a;
return gcd(b,a%b);
}
int main()
{
int s,m,n,i,j,count=1;
long long sum,t;
scanf("%d",&s);
while(s--)
{
sum=1;
scanf("%d %d",&n,&m);
for(i=1;i<=110;i++)
{
sum=sum*m;
if(sum>=n) break;
}
sum=sum*i;
t=gcd(sum,n);
sum=sum/t;n=n/t;
printf("Case %d: %lld/%d\n",count++,sum,n);
}
return 0;
}

125
HDOJ/3961_autoAC.cpp Normal file
View File

@ -0,0 +1,125 @@
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <cstring>
#define sqr(x) ((x)*(x))
using namespace std;
typedef long long ll;
const double eps=1e-9;
const double pi=acos(-1.0);
struct point
{
double x, y;
point() {}
point(double xx, double yy):x(xx), y(yy) {}
point operator + (const point &a) const
{
return point(x+a.x, y+a.y);
}
point operator - (const point &a) const
{
return point(x-a.x, y-a.y);
}
} po[105], cen, s, e, tp[105];
double r;
int t1, t2, t;
int n, pn;
point cg()
{
point p, s, re;
re.x=0.0;
re.y=0.0;
double area=0.0, ar;
p=po[0];
po[n]=po[0];
for(int i=1; i<=n; i++)
{
s=po[i];
ar=p.x*s.y-s.x*p.y;
area+=(ar/2);
re.x+=(p.x+s.x)*ar;
re.y+=(p.y+s.y)*ar;
p=s;
}
re.x/=(6*area);
re.y/=(6*area);
return re;
}
point pointrotate(point o, double ang, point p)
{
point tp;
p.x-=o.x;
p.y-=o.y;
tp.x=p.x*cos(ang)-p.y*sin(ang)+o.x;
tp.y=p.y*cos(ang)+p.x*sin(ang)+o.y;
return tp;
}
double dis(point a, point b)
{
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
double dot(point sp, point ep, point op)
{
return (sp.x-op.x)*(ep.x-op.x)+(sp.y-op.y)*(ep.y-op.y);
}
double cross(point sp, point ep, point op)
{
return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x);
}
double coverdeg(double ang, double d, double r)
{
double neg=1;
if(ang<0)
{
ang=-ang;
neg=-1;
}
double sina=d*sin(ang)/r;
if(sina>1)sina=1;
return neg*(asin(sina)-ang);
}
int main ()
{
int i;
while(~scanf("%lf%lf%lf%lf%lf%d%d%d%d", &s.x, &s.y, &e.x, &e.y, &r, &n, &t1, &t2, &t))
{
for(i=0; i<n; i++)scanf("%lf%lf", &po[i].x, &po[i].y);
cen=cg();
double a2=(double)(t%t2)/t2*2*pi;
for(i=0; i<n; i++)po[i]=pointrotate(cen, a2, po[i]);
double a1=(double)(t%t1)/t1*2*pi;
point newcen=pointrotate(e, a1, cen);
point mov=newcen-cen;
for(i=0; i<n; i++)po[i]=po[i]+mov;
double se=dis(s, e);
double maxang=acos(r/se);
double maxarc=2*maxang*r;
if(dot(s, newcen, e)<0)
{
printf("%.2lf\n", maxarc);
continue;
}
double supang=pi*0.5-maxang;
point up=po[0], lp=po[0];
for(int i=1; i<n; i++)
{
if(cross(up, po[i], s)>eps)up=po[i];
if(cross(lp, po[i], s)<-eps)lp=po[i];
}
double ua=acos(dot(up, e, s)/(se*dis(s, up)));
double la=acos(dot(lp, e, s)/(se*dis(s, lp)));
if(cross(e, up, s)<0)ua=-ua;
if(cross(e, lp, s)<0)la=-la;
double cvua=min(supang, ua), cvla=max(-supang, la);
if(cvua<cvla)
{
printf("%.2lf\n", maxarc);
continue;
}
double coverarc=r*(coverdeg(cvua, se, r)-coverdeg(cvla, se, r));
printf("%.2lf\n", maxarc-coverarc);
}
return 0;
}

135
HDOJ/3962_autoAC.cpp Normal file
View File

@ -0,0 +1,135 @@
#include <stdio.h>
#include <string.h>
#define MAX 40
#define MOD 10007
char dir[MAX];
int hash[256],n,m,total;
struct node {
int flag,in;
node *fail,*next[4];
}*qu[MAX*MAX],arr[MAX*MAX],*root;
node *CreateNode() {
node *p = &arr[total];
p->in = total++;
p->flag = 0;
p->fail = NULL;
for (int i = 0; i < 4; ++i)
p->next[i] = NULL;
return p;
}
void Insert(char *str) {
int i = 0,k;
node *p = root;
while (str[i]) {
k = hash[str[i++]];
if (p->next[k] == NULL)
p->next[k] = CreateNode();
p = p->next[k];
}
p->flag = 1;
}
void Build_AC() {
int head,tail,i;
head = tail = 0;
root->fail = root;
qu[++head] = root;
while (tail < head) {
node *p = qu[++tail];
for (i = 0; i < 4; ++i) {
if (p->next[i] != NULL) {
if (p == root) p->next[i]->fail = root;
else p->next[i]->fail = p->fail->next[i];
qu[++head] = p->next[i];
p->next[i]->flag |= p->fail->next[i]->flag;
}
else {
if (p == root) p->next[i] = root;
else p->next[i] = p->fail->next[i];
}//else
}//for
}//while
}//void
struct Mat{
int mat[MAX*2][MAX*2],size;
Mat(int n) {size = n,memset(mat,0,sizeof(mat));}
Mat(int arr[][MAX*2],int n) { size = n,memcpy(mat,arr,sizeof(arr));}
friend Mat operator *(Mat a,Mat b);
friend Mat operator +(Mat a,Mat b);
friend Mat operator ^(Mat a,int k);
friend Mat Sum(Mat a,int k);
}A(MAX*2),E(MAX*2);
Mat operator *(Mat a,Mat b) {
Mat c(total*2);
for (int i = 0; i < c.size; ++i)
for (int j = 0; j < c.size; ++j)
for (int k = 0; k < c.size; ++k)
if (a.mat[i][k] && b.mat[k][j]) {
c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
c.mat[i][j] %= MOD;
}
return c;
}
Mat operator +(Mat a,Mat b) {
Mat c(total*2);
for (int i = 0; i < c.size; ++i)
for (int j = 0; j < c.size; ++j)
c.mat[i][j] = (a.mat[i][j] + b.mat[i][j]) % MOD;
return c;
}
Mat operator ^(Mat a,int k) {
Mat c = E;
while (k) {
if (k & 1) c = c * a;
a = a * a,k >>= 1;
}
return c;
}
Mat Sum(Mat A,int k) {
if (k == 1) return A;
else if (k & 1) return (A^k) * Sum(A,k-1);
else return Sum(A,k/2) * ((A^(k/2)) + E);
}
void GetMat() {
int i,j,k;
Mat c(total*2);
for (i = 0; i < total; ++i) {
for (k = 0; k < 4; ++k) {
j = arr[i].next[k]->in;
if (arr[i].next[k]->flag)
c.mat[i][j+total]++;
else c.mat[i][j]++,c.mat[i+total][j+total]++;
}
}
E = A = c;
memset(E.mat,0,sizeof(E.mat));
for (i = 0; i < E.size; ++i)
E.mat[i][i] = 1;
}
int Solve_1A() {
int i,j,k,ans,sum;
ans = 1,k = n,sum = 4;
while (k) {
if (k & 1) ans = (ans * sum) % MOD;
sum = (sum * sum) % MOD,k >>= 1;
}
A = A^n;
for (i = 0; i < 2 * total; ++i)
ans = (ans - A.mat[0][i] + MOD) % MOD;
return ans;
}
int main()
{
int i,j,k,ans;
hash['A'] = 0,hash['T'] = 1;
hash['C'] = 2,hash['G'] = 3;
while (scanf("%d%d",&m,&n) != EOF) {
total = 0;
root = CreateNode();
for (i = 0; i < m; ++i)
scanf("%s",dir),Insert(dir);
Build_AC();
GetMat();
ans = Solve_1A();
printf("%d\n",ans % MOD);
}
}

53
HDOJ/3964_autoAC.cpp Normal file
View File

@ -0,0 +1,53 @@
#include<iostream>
using namespace std;
bool map[15][15];
bool mark[15];
int val[15];
int n;
void dfs(int index,int num,int j)
{
int i;
if(num>1&&map[index][j])
{
for(int k=0;k<num;k++)
printf("%d",val[k]);
printf("\n");
}
for(i=j+1;i<n;i++)
{
if(mark[i]==0&&map[index][i])
{
mark[i]=1;
val[num]=i;
dfs(i,num+1,j);
mark[i]=0;
}
}
}
int main()
{
int i,j,a;
//freopen("a.txt","r",stdin);
while(scanf("%d",&n)!=EOF)
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a);
if(a==0)map[i][j]=0;
else map[i][j]=1;
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
mark[j]=0;
mark[i]=1;
val[0]=i;
dfs(i,1,i);
}
printf("\n");
}
return 0;
}

161
HDOJ/3966_autoAC.cpp Normal file
View File

@ -0,0 +1,161 @@
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int MAXN = 50010;
struct Edge
{
int to,next;
}edge[MAXN*2];
int head[MAXN],tot;
int top[MAXN];
int fa[MAXN];
int deep[MAXN];
int num[MAXN];
int p[MAXN];
int fp[MAXN];
int son[MAXN];
int pos;
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
pos = 1;
memset(son,-1,sizeof(son));
}
void addedge(int u,int v)
{
edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
}
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
num[u] = 1;
for(int i = head[u];i != -1; i = edge[i].next)
{
int v = edge[i].to;
if(v != pre)
{
dfs1(v,u,d+1);
num[u] += num[v];
if(son[u] == -1 || num[v] > num[son[u]])
son[u] = v;
}
}
}
void getpos(int u,int sp)
{
top[u] = sp;
p[u] = pos++;
fp[p[u]] = u;
if(son[u] == -1) return;
getpos(son[u],sp);
for(int i = head[u];i != -1;i = edge[i].next)
{
int v = edge[i].to;
if( v != son[u] && v != fa[u])
getpos(v,v);
}
}
int lowbit(int x)
{
return x&(-x);
}
int c[MAXN];
int n;
int sum(int i)
{
int s = 0;
while(i > 0)
{
s += c[i];
i -= lowbit(i);
}
return s;
}
void add(int i,int val)
{
while(i <= n)
{
c[i] += val;
i += lowbit(i);
}
}
void Change(int u,int v,int val)
{
int f1 = top[u], f2 = top[v];
int tmp = 0;
while(f1 != f2)
{
if(deep[f1] < deep[f2])
{
swap(f1,f2);
swap(u,v);
}
add(p[f1],val);
add(p[u]+1,-val);
u = fa[f1];
f1 = top[u];
}
if(deep[u] > deep[v]) swap(u,v);
add(p[u],val);
add(p[v]+1,-val);
}
int a[MAXN];
int main()
{
int M,P;
while(scanf("%d%d%d",&n,&M,&P) == 3)
{
int u,v;
int C1,C2,K;
char op[10];
init();
for(int i = 1;i <= n;i++)
{
scanf("%d",&a[i]);
}
while(M--)
{
scanf("%d%d",&u,&v);
addedge(u,v);
addedge(v,u);
}
dfs1(1,0,0);
getpos(1,1);
memset(c,0,sizeof(c));
for(int i = 1;i <= n;i++)
{
add(p[i],a[i]);
add(p[i]+1,-a[i]);
}
while(P--)
{
scanf("%s",op);
if(op[0] == 'Q')
{
scanf("%d",&u);
printf("%d\n",sum(p[u]));
}
else
{
scanf("%d%d%d",&C1,&C2,&K);
if(op[0] == 'D')
K = -K;
Change(C1,C2,K);
}
}
}
return 0;
}

73
HDOJ/3967_autoAC.cpp Normal file
View File

@ -0,0 +1,73 @@
#include<stdio.h>
#include<math.h>
#include<iostream>
using namespace std;
__int64 a,b,k,num,dp[20][25],d[20][25],C[20],r[20][25],A[20];
__int64 dfs(__int64 now,__int64 left)
{
if(now<0) return 0;
__int64 sum=0,i,j,ii;
for(i=0;i<A[now];i++)
r[now][(left*10+i)%k]++;
for(j=0;j<k;j++)
{
for(i=0;i<10;i++)
r[now][(j*10+i)%k]+=r[now+1][j];
ii=r[now+1][j];
if(!j&&ii>0) ii--;
sum+=ii*dp[now][((k-j)%k+k)%k];
}
if(now!=num)
sum+=d[now][((k-left)%k+k)%k];
sum+=dfs(now-1,(left*10+A[now])%k);
return sum;
}
void dfs2()
{
__int64 i,j,now;
memset(C,0,sizeof(C));
C[0]=1%k;
for(i=1;i<18;i++)
C[i]=(C[i-1]*10)%k;
for(i=0;i<=A[0];i++)
d[0][i%k]++;
for(now=1;now<=num;now++)
{
for(j=0;j<k;j++)
{
d[now][(A[now]*C[now]+j)%k]+=d[now-1][j];
for(i=0;i<A[now];i++)
d[now][(i*C[now]+j)%k]+=dp[now-1][j];
}
}
}
__int64 Cal(__int64 a)
{
__int64 i=0;
while(a)
{
A[i++]=a%10;
a/=10;
}
num=i-1;
memset(d,0,sizeof(d));
memset(r,0,sizeof(r));
dfs2();
return dfs(num,0);
}
int main()
{
__int64 i,j,ii;
while(scanf("%I64d%I64d%I64d",&a,&b,&k)!=EOF)
{
memset(dp,0,sizeof(dp));
for(i=0;i<10;i++)
dp[0][i%k]++;
for(i=1;i<18;i++)
for(ii=0;ii<k;ii++)
for(j=0;j<=9;j++)
dp[i][(ii*10+j)%k]+=dp[i-1][ii];
printf("%I64d\n",Cal(b)-Cal(a-1));
}
return 0;
}

49
HDOJ/3968_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <cstdio>
#include <queue>
#include <cmath>
#include <algorithm>
using namespace std;
#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define clr(a, b) memset(a, b, sizeof(a))
#define SZ(a) ((int)a.size())
#define PB push_back
#define MP make_pair
#define inf 0x3f3f3f3f
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#ifdef ecust
#define R "%lld"
#else
#define R "%I64d"
#endif
namespace acm {
double x0, y0, x1, y1;
double vx, vy;
double t;
double fun(double x){
return 1.0/9.8*(x/2*sqrt(x*x+vx*vx)+vx*vx/2*log(x+sqrt(x*x+vx*vx)));
}
void solve(){
scanf("%lf%lf%lf%lf%lf", &x0, &y0, &x1, &y1, &t);
if(fabs(t) <= 1e-8) {puts("Impossible."); return;}
vx = ((x1 - x0))/t;
vy = ((y1 - y0) + 0.5*9.8*t*t)/t;
printf("%.3lf\n", fun(vy)-fun(vy-9.8*t));
}
void icpc(){
int cas; scanf("%d", &cas);
while(cas--){
solve();
}
}
}
int main() {
acm::icpc();
return 0;
}

277
HDOJ/3969_autoAC.cpp Normal file
View File

@ -0,0 +1,277 @@
#include <iostream>
#include <map>
#include <algorithm>
#include <cstdio>
#include <string>
#include <cstring>
using namespace std;
int main()
{
int i, j, t, n, k;
char team1[55], team2[55], tmp[122], tmp1[55][55], tmp2[55][55], fk[9];
bool chuchang[3][13];
int score[5], pts[5][55], off[5][55], def[5][55], reb[5][55], ast[5][55], pf[5][55], free[5][55][5], three[5][55][5], faqiu[55][55][5], stl[5][55], block[5][55];
scanf("%d", &t);
while(t--)
{
memset(chuchang, 0, sizeof(chuchang));
memset(score, 0, sizeof(score));
memset(pts, 0, sizeof(pts));
memset(off, 0, sizeof(off));
memset(def, 0, sizeof(def));
memset(reb, 0, sizeof(reb));
memset(ast, 0, sizeof(ast));
memset(pf, 0, sizeof(pf));
memset(free, 0, sizeof(free));
memset(three, 0, sizeof(three));
memset(faqiu, 0, sizeof(faqiu));
memset(stl, 0, sizeof(stl));
memset(block, 0, sizeof(block));
map<string, int>teamnum;
map<string, int>num;
scanf("%s %s %s", team1, tmp, team2);
for(i = 1; i <= 12; i++)
{
scanf("%s", tmp1[i]);
string tmpname = tmp1[i];
teamnum[tmpname] = 1;
num[tmpname] = i;
}
for(i = 1; i <= 12; i++)
{
scanf("%s", tmp2[i]);
string tmpname = tmp2[i];
teamnum[tmpname] = 2;
num[tmpname] = i;
}
scanf("%d", &n);
string pre = "", now = "";
bool ispass = 0, twoout = 0, threeout = 0, fa = 0, fangui = 0;
getchar();
for(k = 0; k < n; k++)
{
gets(tmp);
if(k == 0 || k == n - 1) continue;
string str = tmp;
if(str.find("Hold Ball") != -1)
{
int len = str.length() - 10;
string tt = str.substr(0, len);
now = tt;
fangui = false;
}
else if(str.find("Pass to") != -1)
{
string tt = "";
int len = str.length();
for(i = 0; i < len; i++)
{
if(str[i] == ' ') break;
else tt += str[i];
}
pre = tt;
ispass = true;
now = str.substr(pre.length() + 9);
}
else if(str.find("Layup") != -1 || str.find("Slam Dunk") != -1 || str.find("Hook Shot") != -1 || str.find("Jump Shot") != -1 )
twoout = true;
else if(str.find("3pt Shot") != -1)
threeout = true;
else if(str.find("Missed") != -1)
{
if(fa == true)
{
faqiu[teamnum[now]][num[now]][2]++;
fa = false;
}
else if(twoout == true)
{
if(!fangui) free[teamnum[now]][num[now]][2]++;
else fangui = false;
twoout = false;
}
else if(threeout == true)
{
if(!fangui)
{
free[teamnum[now]][num[now]][2]++;
three[teamnum[now]][num[now]][2]++;
}
else fangui = false;
threeout = false;
}
ispass = false;
}
else if(str.find("Made") != -1)
{
if(fa == true)
{
pts[teamnum[now]][num[now]]++;
score[teamnum[now]]++;
faqiu[teamnum[now]][num[now]][2]++;
faqiu[teamnum[now]][num[now]][1]++;
fa = false;
}
else if(twoout)
{
pts[teamnum[now]][num[now]] += 2;
score[teamnum[now]] += 2;
free[teamnum[now]][num[now]][1]++;
free[teamnum[now]][num[now]][2]++;
if(ispass)
{
ast[teamnum[now]][num[pre]]++;
ispass = false;
}
twoout = false;
}
else if(threeout)
{
pts[teamnum[now]][num[now]] += 3;
score[teamnum[now]] += 3;
free[teamnum[now]][num[now]][1]++;
free[teamnum[now]][num[now]][2]++;
three[teamnum[now]][num[now]][2]++;
three[teamnum[now]][num[now]][1]++;
if(ispass)
{
ast[teamnum[now]][num[pre]]++;
ispass = false;
}
threeout = false;
}
ispass = false;
}
else if(str.find("Rebound") != -1)
{
string tt = "";
int len = str.length();
for(i = 0; i < len; i++)
{
if(str[i] == ' ') break;
else tt += str[i];
}
if(teamnum[tt] != teamnum[now])
{
def[teamnum[tt]][num[tt]]++;
reb[teamnum[tt]][num[tt]]++;
}
else if(teamnum[tt] == teamnum[now])
{
off[teamnum[tt]][num[tt]]++;
reb[teamnum[tt]][num[tt]]++;
}
now = tt;
ispass = false;
twoout = false;
threeout = false;
}
else if(str.find("Blocked") != -1)
{
if(threeout)
{
free[teamnum[now]][num[now]][2]++;
three[teamnum[now]][num[now]][2]++;
threeout = false;
}
else if(twoout)
{
free[teamnum[now]][num[now]][2]++;
twoout = false;
}
string tt = str.substr(11);
block[teamnum[tt]][num[tt]]++;
ispass = false;
twoout = false;
threeout = false;
}
else if(str.find("Foul") != -1)
{
string tt = "";
int len = str.length();
for(i = 0; i < len; i++)
{
if(str[i] == ' ') break;
else tt += str[i];
}
pf[teamnum[tt]][num[tt]]++;
if(twoout || threeout)
fangui = true;
}
else if(str.find("Free Throw") != -1)
{
fa = true;
ispass = false;
}
else if(str.find("Substitution") != -1)
{
int len = str.find("Substitution") + 25;
string tt = str.substr(len);
chuchang[teamnum[tt]][num[tt]] = 1;
ispass = false;
twoout = false;
threeout = false;
}
else if(str.find("Timeout") != -1)
ispass = false;
else if(str.find("Jump Ball") != -1)
ispass = false;
else if(str.find("Steal") != -1)
{
string tt = "";
int len = str.length();
for(i = 0; i < len; i++)
{
if(str[i] == ' ') break;
else tt += str[i];
}
stl[teamnum[tt]][num[tt]]++;
now = tt;
ispass = false;
}
}
printf("%s %d-%d %s\n", team1, score[1], score[2], team2);
printf("%s\n", team1);
puts(" PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
for(i = 1; i <= 12; i++)
{
if(i <= 5 || chuchang[1][i] == 1)
{
printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp1[i], pts[1][i], off[1][i], def[1][i], reb[1][i], ast[1][i], stl[1][i], block[1][i], pf[1][i]);
sprintf(fk, "%d-%d", free[1][i][1], free[1][i][2]);
printf("%6s", fk);
sprintf(fk, "%d-%d", three[1][i][1], three[1][i][2]);
printf("%6s", fk);
sprintf(fk, "%d-%d", faqiu[1][i][1], faqiu[1][i][2]);
printf("%6s\n", fk);
}
else
{
printf("%20s", tmp1[i]);
puts(" DNP - Coach's Decision");
}
}
printf("%s\n", team2);
puts(" PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
for(i = 1; i <= 12; i++)
{
if(i <= 5 || chuchang[2][i] == 1)
{
printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp2[i], pts[2][i], off[2][i], def[2][i], reb[2][i], ast[2][i], stl[2][i], block[2][i], pf[2][i]);
sprintf(fk, "%d-%d", free[2][i][1], free[2][i][2]);
printf("%6s", fk);
sprintf(fk, "%d-%d", three[2][i][1], three[2][i][2]);
printf("%6s", fk);
sprintf(fk, "%d-%d", faqiu[2][i][1], faqiu[2][i][2]);
printf("%6s\n", fk);
}
else
{
printf("%20s", tmp2[i]);
puts(" DNP - Coach's Decision");
}
}
puts("");
}
return 0;
}

110
HDOJ/3971_autoAC.cpp Normal file
View File

@ -0,0 +1,110 @@
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
namespace ST
{
typedef long long LL;
const int maxn = 300010;
LL a[maxn];
LL Min[maxn<<2], Max[maxn<<2], add[maxn<<2];
inline void pushUp(int rt)
{
Max[rt] = max(Max[rt<<1], Max[rt<<1|1]);
Min[rt] = min(Min[rt<<1], Min[rt<<1|1]);
}
inline void modify(int rt, LL c)
{
add[rt] += c;
Max[rt] += c;
Min[rt] += c;
}
inline void pushDown(int rt)
{
modify(rt << 1, add[rt]);
modify((rt << 1) | 1, add[rt]);
add[rt] = 0;
}
void build(int l, int r, int rt)
{
add[rt] = 0;
if (l == r) {
Max[rt] = Min[rt] = a[l];
return ;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, (rt << 1) | 1);
pushUp(rt);
}
void update(int l, int r, int rt, LL L, LL R, LL D)
{
if (L > Max[rt] || R < Min[rt]) return ;
if (L <= Min[rt] && R >= Max[rt]) {
modify(rt, D);
return ;
}
if (l == r) return ;
int m = (l + r) >> 1;
pushDown(rt);
update(l, m, rt << 1, L, R, D);
update(m + 1, r, (rt << 1) | 1, L, R, D);
pushUp(rt);
}
int query(int l, int r, int rt, LL L, LL R)
{
if (L > Max[rt] || R < Min[rt]) {
return 0;
}
if (L <= Min[rt] && R >= Max[rt]) {
return r - l + 1;
}
if (l == r) return 0;
int m = (l + r) >> 1;
pushDown(rt);
return query(l, m, rt << 1, L, R) + query(m + 1, r, (rt << 1) | 1, L, R);
}
void getNewArr(int l, int r, int rt)
{
if (l == r) {
a[l] = Max[rt];
return ;
}
int m = (l + r) >> 1;
pushDown(rt);
getNewArr(l, m, rt << 1);
getNewArr(m + 1, r, (rt << 1) | 1);
}
}
int main()
{
using namespace ST;
int n, m;
char op[2];
long long L, R, D;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
build(1, n, 1);
while (m--) {
scanf("%s", op);
if (op[0] == 'C') {
scanf("%lld%lld%lld", &L, &R, &D);
update(1, n, 1, L, R, D);
} else {
scanf("%lld%lld", &L, &R);
printf("%d\n", query(1, n, 1, L, R));
}
if (m % 4500 == 0) {
getNewArr(1, n, 1);
sort(a + 1, a + n + 1);
build(1, n, 1);
}
}
}
return 0;
}

88
HDOJ/3973_autoAC.cpp Normal file
View File

@ -0,0 +1,88 @@
#include<cstdio>
#include<cstring>
#include<map>
#define maxn 100010
#define p 33
using namespace std;
typedef unsigned long long ll;
struct Tree{
int l,r;
ll hashes;
}tree[300000];
char str[2000100];
ll hh[maxn];
void init(){
int i;
hh[0]=1;
for(i=1;i<=maxn;i++)
hh[i]=hh[i-1]*p;
}
ll calhash(){
int i,len=strlen(str);
ll sum=0;
for(i=0;i<len;i++)
sum=sum*p+str[i]-'a'+1;
return sum;
}
void build(int s,int t,int id){
tree[id].l=s;tree[id].r=t;
if(s==t){
tree[id].hashes=str[s]-'a'+1;
return;
}
int mid=(s+t)>>1;
build(s,mid,id<<1);
build(mid+1,t,id<<1|1);
tree[id].hashes=tree[id<<1].hashes*hh[t-mid]+tree[id<<1|1].hashes;
}
void update(int l,int id){
if(tree[id].l==tree[id].r){
tree[id].hashes=str[l]-'a'+1;
return ;
}
int mid=(tree[id].l+tree[id].r)>>1;
if(l<=mid) update(l,id<<1);
else update(l,id<<1|1);
tree[id].hashes=tree[id<<1].hashes*hh[tree[id].r-mid]+tree[id<<1|1].hashes;
}
ll query(int s,int t,int id){
if(tree[id].l==s && tree[id].r==t)
return tree[id].hashes;
int mid=(tree[id].l+tree[id].r)>>1;
if(t<=mid) return query(s,t,id<<1);
else if(s>mid) return query(s,t,id<<1|1);
return query(s,mid,id<<1)*hh[t-mid]+query(mid+1,t,id<<1|1);
}
int main(){
int t,T,pos,l,r,i,q,n;
char s1[10],s2[10];
map<ll,int>mp;
init();
scanf("%d",&T);
for(t=1;t<=T;t++){
printf("Case #%d:\n",t);
scanf("%d",&n);
mp.clear();
for(i=1;i<=n;i++){
scanf("%s",str);
mp.insert(make_pair(calhash(),1));
}
scanf("%s",str);
int len=strlen(str);
build(0,len-1,1);
scanf("%d",&q);
for(i=1;i<=q;i++){
scanf("%s",s1);
if(s1[0]=='C'){
scanf("%d%s",&pos,s2);
str[pos]=s2[0];
update(pos,1);
}
else{
scanf("%d %d",&l,&r);
if(mp.find(query(l,r,1))!=mp.end()) printf("Yes\n");
else printf("No\n");
}
}
}
}

67
HDOJ/3974_autoAC.cpp Normal file
View File

@ -0,0 +1,67 @@
#include <stdio.h>
#include <iostream>
using namespace std;
const int MAX = 50010;
struct NODE
{
int task,count;
};
NODE p[MAX];
int parent[MAX];
void init()
{
memset(parent,-1,sizeof(parent));
}
int main()
{
int ncases,n,u,v,m,x,task;
char s[5];
scanf("%d",&ncases);
int ind=1;
while(ncases--)
{
scanf("%d",&n);
init();
int i;
for(i=0;i<n-1;i++)
{
scanf("%d%d",&u,&v);
parent[u]=v;
}
for(i=1;i<=n;i++)
{
p[i].task=-1;
p[i].count=-1;
}
scanf("%d",&m);
printf("Case #%d:\n",ind++);
int count=0;
while(m--)
{
scanf("%s",s);
if(s[0]=='T')
{
scanf("%d%d",&x,&task);
p[x].task=task;
p[x].count=++count;
}
else
{
scanf("%d",&x);
task=p[x].task;
int count=p[x].count;
while(x!=-1)
{
if(p[x].count>count)
{
task=p[x].task;
count=p[x].count;
}
x=parent[x];
}
printf("%d\n",task);
}
}
}
return 0;
}

40
HDOJ/3975_autoAC.cpp Normal file
View File

@ -0,0 +1,40 @@
#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#define EPS 1e-8
int main(){
int t,i,ca=1;
scanf("%d",&t);
double ti,g=10;
double x0[3],vx[3],vy[3],d[3],v[3];
double a,b,t1,c;
while(t--){
for(i=0;i<3;i++)scanf("%lf",x0+i);
for(i=0;i<3;i++)scanf("%lf",v+i);
for(i=0;i<3;i++)scanf("%lf",d+i);
for(i=0;i<3;i++){
vx[i]=v[i]*cos(d[i]);
vy[i]=v[i]*sin(d[i]);
if(i==0 || ti>2*vy[i]/g)
ti=2*vy[i]/g;
}
a=(vx[0]-vx[1])*(vy[1]-vy[2])-((vx[1]-vx[2])*(vy[0]-vy[1]));
b=(x0[0]-x0[1])*(vy[1]-vy[2])-(x0[1]-x0[2])*(vy[0]-vy[1]);
printf("Case #%d: ",ca++);
if(ti<EPS)
printf("-1\n");
else if(fabs(a)<EPS && fabs(b)<EPS)
printf("Multiply answer\n");
else if(fabs(a)<EPS)
printf("-1\n");
else{
t1=-b/a;
if(t1>EPS && ti-t1>-EPS )
printf("%.4lf\n",t1+EPS);
else
printf("-1\n");
}
}
return 0;
}

79
HDOJ/3976_autoAC.cpp Normal file
View File

@ -0,0 +1,79 @@
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const double eps = 1e-9;
const int MAXN = 100;
double a[MAXN][MAXN],x[MAXN];
int equ,var;
int Gauss()
{
int i,j,k,col,max_r;
for(k = 0,col = 0;k < equ && col < var;k++,col++)
{
max_r = k;
for(i = k+1;i < equ;i++)
if(fabs(a[i][col]) > fabs(a[max_r][col]))
max_r = i;
if(fabs(a[max_r][col]) < eps)return 0;
if(k != max_r)
{
for(j = col;j < var;j++)
swap(a[k][j],a[max_r][j]);
swap(x[k],x[max_r]);
}
x[k]/=a[k][col];
for(j = col+1;j < var;j++)a[k][j]/=a[k][col];
a[k][col] = 1;
for(int i = 0;i < equ;i++)
if(i != k)
{
x[i] -= x[k]*a[i][k];
for(j = col+1;j < var;j++)a[i][j] -= a[k][j]*a[i][col];
a[i][col] = 0;
}
}
return 1;
}
int main()
{
int n,m;
int T;
int iCase = 0;
scanf("%d",&T);
while(T--)
{
iCase++;
scanf("%d%d",&n,&m);
equ = var = n;
memset(a,0,sizeof(a));
int u,v,w;
for(int i = 0;i < m;i++)
{
scanf("%d%d%d",&u,&v,&w);
a[u-1][v-1] += 1.0/w;
a[u-1][u-1] += -1.0/w;
a[v-1][u-1] += 1.0/w;
a[v-1][v-1] += -1.0/w;
}
for(int i = 0;i < n-1;i++)
x[i] = 0;
x[0] = 1;
for(int i = 0;i < n;i++)
a[n-1][i] = 0;
x[n-1] = 0;
a[n-1][0] = 1;
Gauss();
printf("Case #%d: %.2lf\n",iCase,x[n-1]);
}
return 0;
}

207
HDOJ/3977_autoAC.cpp Normal file
View File

@ -0,0 +1,207 @@
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define MAXN 1000005
int prime[MAXN];
int p[MAXN];
int s[MAXN];
vector <int> pmo[MAXN];
int up;
int tag[MAXN];
int ttt[MAXN];
int answer[MAXN];
typedef struct
{
long long m[2][2];
}Matrix;
void Prime()
{
long long i,k;
up=0;
memset(prime,0,sizeof(prime));
for (i=2;i<=MAXN-3;i++)
{
if (prime[i]==1) continue;
k=i;
while(k*i<MAXN-2)
{
prime[i*k]=1;
k++;
}
p[up++]=i;
prime[i]=up-1;
}
}
Matrix Mul(Matrix a,Matrix b,int mod)
{
Matrix c;
int i,j,k;
for (i=0;i<2;i++)
{
for (j=0;j<2;j++)
{
c.m[i][j]=0;
for (k=0;k<2;k++)
{
c.m[i][j]=(c.m[i][j]+a.m[i][k]*b.m[k][j])%mod;
}
}
}
return c;
}
long long CountFib(int t,int mod)
{
Matrix a,b;
int k=t;
a.m[0][0]=a.m[0][1]=a.m[1][0]=b.m[0][0]=1;
a.m[1][1]=b.m[1][0]=b.m[0][1]=b.m[1][1]=0;
while(t)
{
if (t&1)
{
b=Mul(a,b,mod);
}
a=Mul(a,a,mod);
t>>=1;
}
return b.m[0][0];
}
int num[100][2];
int ret;
int now=0;
int Multi(int t,int n)
{
int ans=1;
while(n)
{
if (n&1) ans=ans*t;
t=t*t;
n>>=1;
}
return ans;
}
void DFS(int t,int mod,int mul)
{
int j;
if (mul>=ret) return;
if (t==now)
{
if (CountFib(mul,mod)==1 && CountFib(mul+1,mod)==1) ret=mul;
return;
}
for (j=0;j<=num[t][1];j++)
{
if (num[t][0]==2 && j==0) continue;
int k=mul*Multi(num[t][0],j);
DFS(t+1,mod,k);
}
}
int DT(int t,int mod)
{
int i;
ret=t;
now=0;
for (i=0;i<up;i++)
{
if (t%p[i]!=0) continue;
num[now][0]=p[i];
num[now][1]=0;
while(t%p[i]==0)
{
num[now][1]++;
t/=p[i];
}
now++;
if (t==1) break;
}
if (t!=1)
{
num[now][0]=t;
num[now++][1]=1;
}
DFS(0,mod,1);
return ret;
}
int Count(int t)
{
int i,k,j;
if (t==2)
{
return 3;
}
else if (t==5)
{
return 20;
}
if (t%10==1 || t%10==9) k=t-1;
if (t%10==3 || t%10==7) k=t*2+2;
return DT(k,t);
}
int fj[50][2];
int main()
{
int i,j,m,T,cnt;
long long n;
Prime();
scanf("%d",&T);
cnt=1;
while(T--)
{
scanf("%I64d",&n);
m=0;
for (i=0;i<up;i++)
{
if (n%p[i]==0)
{
fj[m][0]=p[i];
fj[m][1]=0;
while(n%p[i]==0)
{
fj[m][1]++;
n/=p[i];
}
m++;
}
if (n==1) break;
}
memset(answer,0,sizeof(answer));
int mm=0;
for (i=0;i<m;i++)
{
memset(tag,0,sizeof(tag));
if (fj[i][1]>0)
{
mm=max(prime[fj[i][0]],mm);
tag[prime[fj[i][0]]]+=fj[i][1]-1;
}
int tt=Count(fj[i][0]);
for (j=0;j<up;j++)
{
while(tt%p[j]==0)
{
tt/=p[j];
tag[j]++;
mm=max(mm,j);
}
if (tt==1) break;
}
for (j=0;j<=mm;j++)
{
answer[j]=max(tag[j],answer[j]);
}
}
long long pr=1;
for (i=0;i<=mm;i++)
{
for (j=0;j<answer[i];j++)
{
pr*=p[i];
}
}
printf("Case #%d: %I64d\n",cnt++,pr);
}
return 0;
}

197
HDOJ/3978_autoAC.cpp Normal file
View File

@ -0,0 +1,197 @@
#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
#define maxn 10010
typedef long long LL;
int prime[maxn];
map<LL,LL>pika;
void Prime(){
memset(prime,0,sizeof(prime));
for(int i=2;i<maxn;i++){
if(!prime[i]) prime[++prime[0]]=i;
for(int j=1;j<=prime[0]&&prime[j]<maxn/i;j++){
prime[prime[j]*i]=1;
if(i%prime[j]==0){
break;
}
}
}
}
LL factor[100][2];
int fatcnt;
int get_factors(LL n){
fatcnt=0;
LL tmp=n;
for(int i=1;prime[i]<=tmp/prime[i];i++){
factor[fatcnt][1]=0;
if(tmp%prime[i]==0){
factor[fatcnt][0]=prime[i];
while(tmp%prime[i]==0){
tmp/=prime[i];
factor[fatcnt][1]++;
}
fatcnt++;
}
}
if(tmp!=1){
factor[fatcnt][0]=tmp;
factor[fatcnt][1]=1;
fatcnt++;
}
return fatcnt;
}
LL gcd(LL a,LL b){
if(b==0){
return a;
}
else{
return gcd(b,a%b);
}
}
LL lcm(LL a,LL b){
return a/gcd(a,b)*b;
}
struct Matrix{
LL m[2][2];
}E,D;
Matrix Multi(Matrix A,Matrix B,LL mod){
Matrix ans;
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
ans.m[i][j]=0;
for(int k=0;k<2;k++){
ans.m[i][j]+=(A.m[i][k]*B.m[k][j])%mod;
if(ans.m[i][j]>=mod){
ans.m[i][j]-=mod;
}
}
}
}
return ans;
}
void init(){
memset(E.m,0,sizeof(E.m));
memset(D.m,0,sizeof(D.m));
D.m[0][0]=D.m[0][1]=D.m[1][0]=1;
for(int i=0;i<2;i++){
E.m[i][i]=1;
}
Prime();
}
Matrix Pow(Matrix A,LL e,LL mod){
Matrix ans=E;
while(e){
if(e&1){
ans=Multi(ans,A,mod);
}
A=Multi(A,A,mod);
e>>=1;
}
return ans;
}
LL Pow(LL a,LL b,LL mod){
LL ans=1;
while(b){
if(b&1){
ans=(ans*a)%mod;
}
a=(a*a)%mod;
b>>=1;
}
return ans;
}
int legendre(LL a,LL p){
if(Pow(a,(p-1)>>1,p)==1){
return 1;
}
else{
return -1;
}
}
int f0=1,f1=1;
LL get_fib(LL n,LL mod)
{
if(mod==1) return 0;
return Pow(D,n,mod).m[0][0]%mod;
}
LL fac[maxn],GG[maxn];
LL G(LL p)
{
if(p<maxn && GG[p]!=-1) return GG[p];
LL num;
if(legendre(5,p)==1){
num=p-1;
}
else{
num=2*(p+1);
}
int cnt=0;
for(LL i=1;i*i<=num;i++){
if(num%i==0){
fac[cnt++]=i;
if(i*i!=num){
fac[cnt++]=num/i;
}
}
}
sort(fac,fac+cnt);
LL ans;
for(int i=0;i<cnt;i++){
if(get_fib(fac[i],p)==f0&&get_fib(fac[i]+1,p)==f1){
ans=fac[i];
break;
}
}
if(p<maxn) GG[p]=ans;
return ans;
}
LL find_loop(LL n)
{
if(pika.count(n)){
return pika[n];
}
get_factors(n);
LL ans=1;
for(int i=0;i<fatcnt;i++)
{
LL record=1;
if(factor[i][0]==2) record=3;
else if(factor[i][0]==3) record=8;
else if(factor[i][0]==5) record=20;
else record=G(factor[i][0]);
for(int j=1;j<factor[i][1];j++)
record*=factor[i][0];
ans=lcm(ans,record);
}
return pika[n]=ans;
}
LL loop[10010];
void solve(LL p,LL k){
loop[0]=p;
for(int i=1;i<=k;i++){
loop[i]=find_loop(loop[i-1]);
}
}
int main()
{
pika.clear();
init();
memset(GG,-1,sizeof(GG));
int T,cas=0;
scanf("%d",&T);
LL n,p,k;
while(T--)
{
scanf("%I64d%I64d%I64d",&n,&k,&p);
solve(p,k);
for(int i=k;i>=0;i--){
n=get_fib(n,loop[i]);
}
printf("Case #%d: %I64d\n",++cas,n);
}
return 0;
}

48
HDOJ/3979_autoAC.cpp Normal file
View File

@ -0,0 +1,48 @@
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
struct Node
{
int h,g;
}node[10010];
int n,m;
bool cmp(Node a,Node b)
{
return a.h*b.g < b.h*a.g;
}
int main()
{
int T;
int iCase = 0;
scanf("%d",&T);
while(T--)
{
iCase ++;
scanf("%d%d",&n,&m);
for(int i = 0;i < n;i++)
{
scanf("%d%d",&node[i].h,&node[i].g);
node[i].h = (node[i].h + m - 1)/m;
}
sort(node,node+n,cmp);
long long ans = 0;
int cnt = 0;
for(int i = 0;i < n;i++)
{
cnt += node[i].h;
ans += (long long)cnt*node[i].g;
}
printf("Case #%d: %I64d\n",iCase,ans);
}
return 0;
}

31
HDOJ/3980_autoAC.cpp Normal file
View File

@ -0,0 +1,31 @@
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;
int t, n, m;
int f[1005];
bool emerge[1000];
int get_sg(int len)
{
if(len<m) return f[len]=0;
if(f[len]!=-1) return f[len];
bool vs[1001]={0};
for(int i=0; len-i-m>=0; i++)
vs[get_sg(i)^get_sg(len-i-m)]=1;
for(int i=0; i<1001; i++)
if(!vs[i]) return f[len]=i;
}
int main()
{
scanf("%d", &t);
for(int ca=1; ca<=t; ca++)
{
scanf("%d%d", &n, &m);
memset(f, -1, sizeof(f));
printf("Case #%d: ", ca);
if(n<m || get_sg(n-m)) printf("abcdxyzk\n");
else printf("aekdycoin\n");
}
return 0;
}

101
HDOJ/3981_autoAC.cpp Normal file
View File

@ -0,0 +1,101 @@
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <set>
#include <map>
#include <queue>
#include <cmath>
#include <algorithm>
using namespace std;
#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define clr(a, b) memset(a, b, sizeof(a))
#define SZ(a) ((int)a.size())
#define PB push_back
#define MP make_pair
#define inf 0x3f3f3f3f
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#ifdef ecust
#define RR "%lld"
#else
#define RR "%I64d"
#endif
namespace acm {
int dp[2][220][10][220];
int T, HS, A, R, U, D, FI, P;
int des[300];
void update(int &a, int b) {
a = max(a, b);
}
void solve() {
scanf("%d%d%d%d", &T, &HS, &A, &R);
scanf("%d%d%d%d", &U, &D, &FI, &P);
forn(i, T)
scanf("%d", des + i + 1);
clr(dp, 0x3f);
forn(i, 2)
forn(j, 220)
forn(k, 10)
forn(l, 220)
dp[i][j][k][l] = -inf;
int now = 0;
dp[0][HS][0][0] = 0;
for (int tt = 1; tt <= T; ++tt) {
int fang = des[tt];
for (int i = 1; i <= HS; ++i) {
for (int j = 0; j <= 6; ++j) {
for (int k = 0; k <= T; ++k) {
if (dp[now][i][j][k] == -inf)
continue;
if (i > D) {
int add = A + (HS - i) / R * U;
if (add < fang)
add = 0;
else
add -= fang;
update(dp[now ^ 1][i - D][6][k + 1], dp[now][i][j][k]
+ add + FI * k);
}
int add = A + (HS - i) / R * U;
if (add < fang)
add = 0;
else
add -= fang;
if (j - 1 == 0)
update(dp[now ^ 1][i][j - 1][0], dp[now][i][j][k] + add
+ FI * k);
else if (j)
update(dp[now ^ 1][i][j - 1][k], dp[now][i][j][k] + add
+ FI * k);
else if (j == 0)
update(dp[now ^ 1][i][j][k], dp[now][i][j][k] + add);
}
}
}
now = now ^ 1;
}
int ans = -inf, ans2 = -inf;
forn(j, 220)
forn(k, 10)
forn(l, 220) {
if (dp[now ][j][k][l] != inf) {
update(ans, dp[now ][j][k][l] - (HS - j) * P);
}
}
printf("%d\n", ans);
}
void icpc() {
int nc, nn = 1;
scanf("%d", &nc);
while (nc--) {
printf("Case #%d: ", nn++);
solve();
}
}
}
int main() {
acm::icpc();
return 0;
}

267
HDOJ/3982_autoAC.cpp Normal file
View File

@ -0,0 +1,267 @@
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <limits.h>
#include <string.h>
#include <string>
#include <algorithm>
#define MID(x,y) ( ( x + y ) >> 1 )
#define L(x) ( x << 1 )
#define R(x) ( x << 1 | 1 )
#define FOR(i,s,t) for(int i=s; i<t; i++)
#define BUG puts("here!!!")
using namespace std;
const int MAX = 2010;
struct point {
double x,y;
void P(double xx, double yy){ x = xx; y = yy;}
void get(){ scanf("%lf%lf",&x, &y);}
};
struct line { point a,b; double ang;};
point s[MAX*2], ch, p[MAX*2];
line l[MAX*2],deq[MAX*2];
const double eps = 1e-6;
const double pi = acos(-1.0);
bool dy(double x,double y) { return x > y + eps;}
bool xy(double x,double y) { return x < y - eps;}
bool dyd(double x,double y) { return x > y - eps;}
bool xyd(double x,double y) { return x < y + eps;}
bool dd(double x,double y) { return fabs( x - y ) < eps;}
double crossProduct(point a,point b,point c)
{
return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);
}
double disp2p(point a,point b)
{
return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
}
bool parallel(line u,line v)
{
return dd( (u.a.x - u.b.x)*(v.a.y - v.b.y) - (v.a.x - v.b.x)*(u.a.y - u.b.y) , 0.0 );
}
point l2l_inst_p(line l1,line l2)
{
point ans = l1.a;
double t = ((l1.a.x - l2.a.x)*(l2.a.y - l2.b.y) - (l1.a.y - l2.a.y)*(l2.a.x - l2.b.x))/
((l1.a.x - l1.b.x)*(l2.a.y - l2.b.y) - (l1.a.y - l1.b.y)*(l2.a.x - l2.b.x));
ans.x += (l1.b.x - l1.a.x)*t;
ans.y += (l1.b.y - l1.a.y)*t;
return ans;
}
bool equal_ang(line a,line b)
{
return dd(a.ang,b.ang);
}
bool cmphp(line a,line b)
{
if( dd(a.ang,b.ang) ) return xy(crossProduct(b.a,b.b,a.a),0.0);
return xy(a.ang,b.ang);
}
bool equal_p(point a,point b)
{
return dd(a.x,b.x) && dd(a.y,b.y);
}
void makeline_hp(double x1,double y1,double x2,double y2,line &l)
{
l.a.x = x1; l.a.y = y1; l.b.x = x2; l.b.y = y2;
l.ang = atan2(y2 - y1,x2 - x1);
}
void inst_hp_nlogn(line *ln,int n,point *s,int &len)
{
len = 0;
sort(ln,ln+n,cmphp);
n = unique(ln,ln+n,equal_ang) - ln;
int bot = 0,top = 1;
deq[0] = ln[0]; deq[1] = ln[1];
for(int i=2; i<n; i++)
{
if( parallel(deq[top],deq[top-1]) || parallel(deq[bot],deq[bot+1]) )
return ;
while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,
l2l_inst_p(deq[top],deq[top-1])),0.0) )
top--;
while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,
l2l_inst_p(deq[bot],deq[bot+1])),0.0) )
bot++;
deq[++top] = ln[i];
}
while( bot < top && dy(crossProduct(deq[bot].a,deq[bot].b,
l2l_inst_p(deq[top],deq[top-1])),0.0) ) top--;
while( bot < top && dy(crossProduct(deq[top].a,deq[top].b,
l2l_inst_p(deq[bot],deq[bot+1])),0.0) ) bot++;
if( top <= bot + 1 ) return ;
for(int i=bot; i<top; i++)
s[len++] = l2l_inst_p(deq[i],deq[i+1]);
if( bot < top + 1 ) s[len++] = l2l_inst_p(deq[bot],deq[top]);
len = unique(s,s+len,equal_p) - s;
}
point l2l_inst_p(point u1,point u2,point v1,point v2)
{
point ans = u1;
double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
ans.x += (u2.x - u1.x)*t;
ans.y += (u2.y - u1.y)*t;
return ans;
}
void l2c_inst_p(point c,double r,point l1,point l2,point &p1,point &p2)
{
point p = c;
double t;
p.x += l1.y - l2.y;
p.y += l2.x - l1.x;
p = l2l_inst_p(p,c,l1,l2);
t = sqrt(r*r - disp2p(p,c)*disp2p(p,c))/disp2p(l1,l2);
p1.x = p.x + (l2.x - l1.x)*t;
p1.y = p.y + (l2.y - l1.y)*t;
p2.x = p.x - (l2.x - l1.x)*t;
p2.y = p.y - (l2.y - l1.y)*t;
}
double disp2l(point a,point l1,point l2)
{
return fabs( crossProduct(a,l1,l2) )/disp2p(l1,l2);
}
bool onSegment(point a, point b, point c)
{
if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,min(a.x,b.x)) &&
xyd(c.x,max(a.x,b.x)) && dyd(c.y,min(a.y,b.y)) && xyd(c.y,max(a.y,b.y)) )
return true;
return false;
}
bool cmp(point a,point b)
{
double t1 = atan2(a.y - ch.y, a.x - ch.x);
double t2 = atan2(b.y - ch.y, b.x - ch.x);
return xy(t1, t2);
}
double area_triangle(point a,point b,point c)
{
return fabs( crossProduct(a,b,c) )/2.0;
}
double gong_area(point c,point a,point b,double r)
{
if( dd(crossProduct(c,a,b), 0.0) )
return r*r*pi/2;
double area = area_triangle(a, b, c);
double ang = acos(1-disp2p(a,b)*disp2p(a,b)/(r*r*2));
return ang*r*r/2 - area;
}
bool incircle(point a,point c, double r)
{
return xy(disp2p(a, c), r);
}
bool pin_convexh(point *p,int n,point a)
{
p[n] = p[0]; p[n+1] = p[1];
for(int i=0; i<n; i++)
if( xy(crossProduct(p[i],p[i+1],a)*
crossProduct(p[i+1],p[i+2],a),0.0) )
return false;
return true;
}
point foot_line(point a,point l1,point l2)
{
point c;
c.x = a.x - l2.y + l1.y;
c.y = a.y + l2.x - l1.x;
return c;
}
double solve(point *s, int len, double r)
{
point c; c.x = c.y = 0;
point a, b;
int cnt = 0;
s[len] = s[0];
FOR(i, 0, len)
{
if( xy(disp2l(c, s[i], s[i+1]), r) )
{
l2c_inst_p(c, r, s[i], s[i+1], a, b);
if( onSegment(s[i], s[i+1], a) )
p[cnt++] = a;
if( onSegment(s[i], s[i+1], b) )
p[cnt++] = b;
}
if( incircle(s[i], c, r) )
p[cnt++] = s[i];
if( incircle(s[i+1], c, r) )
p[cnt++] = s[i+1];
}
sort(p, p+cnt, cmp);
cnt = unique(p, p+cnt, equal_p) - p;
p[cnt] = p[0];
double area = 0.0;
if( cnt == 2 )
{
if( xy(crossProduct(p[0],p[1],ch), 0.0) )
swap(p[0], p[1]);
cnt--;
}
FOR(i, 0, cnt)
{
area += area_triangle(p[0], p[i], p[i+1]);
if( !dd(disp2p(p[i], c), r) || !dd(disp2p(p[i+1], c), r) )
continue;
point mid;
mid.P((p[i].x + p[i+1].x)/2, (p[i].y + p[i+1].y)/2);
point a, b, k;
k = foot_line(c, p[i], p[i+1]);
l2c_inst_p(c, r, k, c, a, b);
bool flag = false;
if( dyd(crossProduct(p[i], p[i+1], a), 0.0) && pin_convexh(s, len, a) )
flag = true;
if( dyd(crossProduct(p[i], p[i+1], b), 0.0) && pin_convexh(s, len, b) )
flag = true;
if( !flag ) continue;
double area_gong = gong_area(c, p[i], p[i+1], r);
if( dy(crossProduct(p[i], p[i+1], c), 0.0) )
area_gong = pi*r*r - area_gong;
area += area_gong;
}
return area/(pi*r*r);
}
int main()
{
int ncases, ind = 1, n;
double r;
scanf("%d", &ncases);
while( ncases-- )
{
scanf("%lf%d",&r, &n);
FOR(i, 0, n)
{
l[i].a.get();
l[i].b.get();
}
ch.get();
bool f = false;
point c; c.P(0,0);
FOR(i, 0, n)
{
if( dy(crossProduct(l[i].a, l[i].b, ch), 0.0) )
swap(l[i].a, l[i].b);
l[i].ang = atan2(l[i].b.y - l[i].a.y, l[i].b.x - l[i].a.x);
if( xy(disp2l(c,l[i].a, l[i].b), r) )
f = true;
}
if( !f )
{
printf("Case %d: %.5lf%%\n",ind++, 100.0);
continue;
}
makeline_hp(-2*r, -2*r, 2*r, -2*r, l[n++]);
makeline_hp(2*r, -2*r, 2*r, 2*r, l[n++]);
makeline_hp(2*r, 2*r, -2*r, 2*r, l[n++]);
makeline_hp(-2*r, 2*r, -2*r, -2*r, l[n++]);
int len;
inst_hp_nlogn(l, n, s, len);
double ans = solve(s, len, r);
printf("Case %d: %.5lf%%\n",ind++, ans*100);
}
return 0;
}

88
HDOJ/3986_autoAC.cpp Normal file
View File

@ -0,0 +1,88 @@
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
const int MAXN=1000+10;
const int inf=1<<30;
struct Node{
int v,w,id;
};
vector<Node>vet[MAXN];
int path[MAXN];
int dist[MAXN];
bool visited[MAXN];
bool mark[MAXN*50];
int id[MAXN];
int n,m;
bool tag;
void SPFA(int u){
for(int i=1;i<=n;i++)dist[i]=inf;
dist[u]=0;
memset(visited,false,sizeof(visited));
queue<int>Q;
Q.push(u);
while(!Q.empty()){
int u=Q.front();
Q.pop();
visited[u]=false;
for(int i=0;i<vet[u].size();i++){
int v=vet[u][i].v;
int w=vet[u][i].w;
int ID=vet[u][i].id;
if(mark[vet[u][i].id])continue;
if(dist[u]+w<dist[v]){
dist[v]=dist[u]+w;
if(tag)path[v]=u,id[v]=ID;
if(!visited[v]){
Q.push(v);
visited[v]=true;
}
}
}
}
}
int main(){
int _case;
scanf("%d",&_case);
while(_case--){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)vet[i].clear();
memset(path,-1,sizeof(path));
memset(mark,false,sizeof(mark));
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
Node p1,p2;
p1.v=u,p2.v=v;
p1.w=p2.w=w;
p1.id=p2.id=i;
vet[u].push_back(p2);
vet[v].push_back(p1);
}
tag=true;
SPFA(1);
tag=false;
if(dist[n]==inf){
printf("-1\n");
continue;
}
int ans=0;
bool flag=true;
for(int u=n;u!=-1;u=path[u]){
mark[id[u]]=true;
SPFA(1);
mark[id[u]]=false;
if(dist[n]==inf){
printf("-1\n");
flag=false;
break;
}
ans=max(ans,dist[n]);
}
if(flag){
printf("%d\n",ans);
}
}
return 0;
}

83
HDOJ/3987_autoAC.cpp Normal file
View File

@ -0,0 +1,83 @@
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
#define MAXN 2222
#define MAXM 2222222
struct Edge{
int v,next;
ll cap;
}edge[MAXM];
int head[MAXN];
int pre[MAXN];
int cur[MAXN];
int level[MAXN];
int gap[MAXN];
int NV,NE,n,m,vs,vt;
void Insert(int u,int v,ll cap,ll cc=0){
edge[NE].v=v;edge[NE].cap=cap;
edge[NE].next=head[u];head[u]=NE++;
edge[NE].v=u;edge[NE].cap=cc;
edge[NE].next=head[v];head[v]=NE++;
}
ll SAP(int vs,int vt){
memset(pre,-1,sizeof(pre));
memset(level,0,sizeof(level));
memset(gap,0,sizeof(gap));
for(int i=0;i<=NV;i++)cur[i]=head[i];
int u=pre[vs]=vs;
ll aug=-1,maxflow=0;
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[u];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 _case,u,v,w,flag,t=1;
scanf("%d",&_case);
while(_case--){
scanf("%d%d",&n,&m);
vs=0,vt=n-1,NV=n,NE=0;
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
scanf("%d%d%d%d",&u,&v,&w,&flag);
Insert(u,v,(ll)w*MAXM+1);
if(flag)Insert(v,u,(ll)w*MAXM+1);
}
ll ans=SAP(vs,vt);
printf("Case %d: %d\n",t++,ans%MAXM);
}
return 0;
}

71
HDOJ/3988_autoAC.cpp Normal file
View File

@ -0,0 +1,71 @@
#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define N 100005
#define MOD 9973
#define LL unsigned long long
#define eps 1e-7
#define zero(a) fabs(a)<eps
#define equal(a,b) zero(a-b)
using namespace std;
bool flag[10000005];
int cnt=0,prime[10000005];
void Init(){
for(int i=2;i<=sqrt(10000000.0)+1;i++){
if(flag[i])
continue;
for(int j=2;j*i<=10000000;j++)
flag[i*j]=true;
}
for(int i=2;i<=10000000;i++)
if(!flag[i])
prime[cnt++]=i;
}
LL get_sum(LL n,LL p){
LL ret=0;
while(n){
n/=p;
ret+=n;
}
return ret;
}
int main(){
int t,cas=0;
scanf("%d",&t);
Init();
while(t--){
LL n,k;
scanf("%I64u%I64u",&n,&k);
if(k==1){
printf("Case %d: inf\n",++cas);
continue;
}
LL mmax=-1;
for(int i=0;i<cnt&&prime[i]<=k;i++){
if(k%prime[i]==0){
int c=0;
while(k%prime[i]==0){
c++;
k/=prime[i];
}
LL tmp=get_sum(n,prime[i])/c;
if(mmax==-1)
mmax=tmp;
else
mmax=min(mmax,tmp);
}
}
if(k>1){
LL tmp=get_sum(n,k);
if(mmax==-1)
mmax=tmp;
else
mmax=min(mmax,tmp);
}
printf("Case %d: %I64u\n",++cas,mmax);
}
return 0;
}

110
HDOJ/3991_autoAC.cpp Normal file
View File

@ -0,0 +1,110 @@
#include <cstdio>
#include <cstring>
struct EDGE
{
int v, next;
}edge[2010010];
struct NODE
{
int p;
long long t;
}node[1010];
const long long inf = 1ll<<60;
long long map[105][105];
bool usedif[1005];
int link[1005];
int head[1010];
int cnt, gx, gy;
bool cmp(NODE a, NODE b)
{
return a.t < b.t;
}
void addedge(int u, int v)
{
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
bool can(int t)
{
for(int p = head[t]; p != -1; p = edge[p].next)
{
int i = edge[p].v;
if(usedif[i]==0)
{
usedif[i]=1;
if(link[i]==-1||can(link[i]))
{
link[i]=t;
return true;
}
}
}
return false;
}
int MaxMatch()
{
int num=0;
memset(link,-1,sizeof(link));
for(int i=0; i< gx; i++)
{
memset(usedif,0,sizeof(usedif));
if(can(i)) num++;
}
return num;
}
int main()
{
int T;
scanf("%d", &T);
int cas = 1;
while(T--)
{
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int d = 1<< 30;
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
if(i != j) map[i][j] = inf;
else map[i][j] = 0;
while(m--)
{
int a, b;
long long c;
scanf("%d%d%I64d", &a, &b, &c);
if(map[a][b] > c)
{
map[a][b] = map[b][a] = c;
}
}
for(int k = 0; k < n; k++)
for(int i = 0; i < n; i++)
{
if(i == k) continue;
if(map[i][k] == inf) continue;
for(int j = 0; j < n; j++)
if(map[k][j] != inf && map[i][k] + map[k][j] < map[i][j])
{
map[i][j] = map[i][k] + map[k][j];
}
}
for(int i = 0; i < q; i++)
{
scanf("%d%d", &node[i].p, &node[i].t);
}
gx = q;
cnt = 0;
memset(head, -1, sizeof(head));
for(int i = 0; i < q; i++)
{
for(int j = 0; j < q; j++)
if(i != j && node[j].t - node[i].t >= map[node[i].p][node[j].p])
{
addedge(i, j);
}
}
int ans = gx - MaxMatch();
printf("Case %d: %d\n", cas++, ans - 1);
}
return 0;
}

190
HDOJ/3992_autoAC.cpp Normal file
View File

@ -0,0 +1,190 @@
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn=100000;
struct Node
{
int flag;
int id;
Node* next[26];
Node* fail;
};
Node* root;
Node temp[maxn];
int tp;
void reset(Node* p)
{
p->flag=0;p->id=tp-1;
for(int i=0;i<26;i++) p->next[i]=NULL;
p->fail=root;
if(p==root) p->fail=NULL;
}
void init()
{
tp=0;
root=&temp[tp++];
reset(root);
}
void insert(char* str)
{
Node* p=root;
for(int i=0;str[i];i++)
{
int x=str[i]-'a';
if(p->next[x]==NULL)
{
p->next[x]=&temp[tp++];
reset(p->next[x]);
}
p=p->next[x];
}
p->flag=1;
}
Node* que[maxn];
int front,rear;
void DFA()
{
front=rear=0;
que[rear++]=root;
while(front<rear)
{
Node* t=que[front++];
for(int i=0;i<26;i++)
{
Node* cnt=t->next[i];
if(cnt!=NULL)
{
Node* fath=t->fail;
while(fath!=NULL&&fath->next[i]==NULL)
{
fath=fath->fail;
}
if(fath==NULL)
{
cnt->fail=root;
}
else cnt->fail=fath->next[i];
cnt->flag|=cnt->fail->flag;
que[rear++]=cnt;
}
}
}
}
double pet[26];
int n;
char str[maxn];
double a[1000][1000];
int equ,var;//浠0寮濮
void toMatrix()
{
var=rear;
equ=0;
memset(a,0,sizeof(a));
for(int i=0;i<rear;i++)
{
Node* p=&temp[i];
if(p->flag)
{
a[equ][p->id]=1;
a[equ++][var]=0;
continue;
}
a[equ][p->id]=-1;
a[equ][var]=-1;
for(int j=0;j<26;j++)
{
Node* cnt=p->next[j];
int k;
if(cnt!=NULL)
{
k=cnt->id;
a[equ][k]+=pet[j];
}
else
{
Node* fath=p->fail;
while(fath!=NULL&&fath->next[j]==NULL)
{
fath=fath->fail;
}
if(fath!=NULL)
{
k=fath->next[j]->id;
a[equ][k]+=pet[j];
}
else
{
k=0;
a[equ][0]+=pet[j];
}
}
}
equ++;
}
}
const double eps=1e-10;
double x[1000];
void Gauss()
{
for(int i=0;i<equ;i++)
{
int j;
for(j=i;j<equ;j++)
{
if(fabs(a[j][i])>eps) break;
}
for(int k=i;k<=var;k++) swap(a[i][k],a[j][k]);
for(j=i+1;j<equ;j++)
{
double p=-a[j][i]/a[i][i];
for(int k=i;k<=var;k++) a[j][k]+=a[i][k]*p;
}
}
for(int i=equ-1;i>=0;i--)
{
x[i]=a[i][var]/a[i][i];
a[i][var]/=a[i][i];a[i][i]=1;
for(int j=i-1;j>=0;j--)
{
a[j][var]+=-a[j][i]*a[i][var];
a[j][i]=0;
}
}
}
int main()
{
while(scanf("%d",&n)==1)
{
init();
for(int i=0;i<26;i++) scanf("%lf",&pet[i]);
int flag=0;
for(int i=0;i<n;i++)
{
scanf("%s",str);
insert(str);
int f=1;
for(int j=0;str[j];j++)
{
int x=str[j]-'a';
if(fabs(pet[x])<eps)
{
f=0;break;
}
}
if(f) flag=1;
}
if(!flag)
{
printf("Infinity\n");
continue;
}
DFA();
toMatrix();
Gauss();
printf("%.6lf\n",x[0]);
}
return 0;
}

24
HDOJ/3993_autoAC.cpp Normal file
View File

@ -0,0 +1,24 @@
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
int a[20];
int b[20];
int main(){
int test,n;
scanf("%d",&test);
while (test--){
scanf("%d",&n);
for (int i=0;i<n;i++)
scanf("%d",&a[i]);
for (int j=0;j<n;j++)
scanf("%d",&b[j]);
int ans=0;
for (int i=0;i<n;i++)
for (int j=0;j<n;j++)
if (b[i]>a[j]) ans+=3;
printf("%.6lf\n",ans*1.0/n);
}
return 0;
}

97
HDOJ/3994_autoAC.cpp Normal file
View File

@ -0,0 +1,97 @@
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define MaxN 200
#define eps 1e-8
double dp[MaxN+5][MaxN+5];
double tmp[MaxN+5][MaxN+5];
int n;
int c;
int m;
int lst[MaxN+5];
void floyd(bool flag){
int i,j,k;
if (flag){
for (k=0;k<n;k++){
for (i=0;i<n;i++){
for (j=0;j<n;j++){
if ((i==j) || (j==k) || (i==k)) continue;
if (dp[i][j]<dp[i][k]*dp[k][j]){
dp[i][j]=dp[i][k]*dp[k][j];
}
}
}
}
return;
}
for (k=0;k<n;k++){
for (i=0;i<n;i++){
for (j=0;j<n;j++){
if ((i==j) || (j==k) || (i==k)) continue;
if (dp[i][k]>=0 && dp[k][j]>=0 && (dp[i][j]<0 || dp[i][j]>dp[i][k]+dp[k][j])){
dp[i][j]=dp[i][k]+dp[k][j];
}
}
}
}
}
bool iszero(double a)
{
return a<eps;
}
void init(){
int i,j;
scanf("%d",&n);
for (i=0;i<n;i++){
for (j=0;j<n;j++){
scanf("%lf",&dp[i][j]);
dp[i][j]=dp[i][j]/100.0;
}
}
floyd(1);
scanf("%d",&m);
for (i=0;i<m;i++){
scanf("%d",&lst[i]);
}
for (i=0;i<m;i++){
if (lst[i]==1) break;
}
if (i==m) lst[m++]=1;
for (i=0;i<m;i++){
if (lst[i]==2) break;
}
if (i==m) lst[m++]=2;
sort(lst,lst+m);
for (i=0;i<m;i++){
for (j=i+1;j<m;j++){
tmp[i][j]=dp[lst[i]-1][lst[j]-1];
tmp[j][i]=dp[lst[j]-1][lst[i]-1];
}
}
for (i=0;i<m;i++){
for (j=0;j<m;j++){
if (iszero(tmp[i][j]))dp[i][j]=-1;
else dp[i][j]=1.0/tmp[i][j];
if (iszero(tmp[j][i]))dp[j][i]=-1;
else dp[j][i]=1.0/tmp[j][i];
}
}
n=m;
scanf("%d",&c);
floyd(0);
}
void solve(){
printf("%.6lf\n",dp[0][1]*c);
}
int main()
{
int t;
scanf("%d",&t);
while (t--){
init();
solve();
}
return 0;
}

90
HDOJ/3995_autoAC.cpp Normal file
View File

@ -0,0 +1,90 @@
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define sqr(a) ((a)*(a))
#define trarea(p) fabs ((vdet(p[0],p[1],p[2])/2.0))
double const EPS = 1e-12;
int const maxn = 20011;
struct point{double x,y;int flag;};
struct circle{
point c;
double r;
};
inline double vdet(point op,point p1,point p2){
return (p1.x-op.x)*(p2.y-op.y)-(p2.x-op.x)*(p1.y-op.y);
}
inline double dis(point a,point b){
return sqr(a.x-b.x)+sqr(a.y-b.y);
}
inline point get_out_circle(point p[]){
double c1,c2,xa,xb,xc,ya,yb,yc;
point o;
xa=p[0].x,xb=p[1].x,xc=p[2].x;
ya = p[0].y,yb = p[1].y,yc = p[2].y;
c1 = (sqr(xa) + sqr(ya) - sqr(xb) - sqr(yb))/2.0;
c2 = (sqr(xa) + sqr(ya) - sqr(xc) - sqr(yc))/2.0;
o.x = (c1*(ya-yc)-c2*(ya-yb))/((xa-xb)*(ya-yc)-(xa-xc)*(ya-yb));
o.y = (c1*(xa-xc)-c2*(xa-xb))/((ya-yb)*(xa-xc)-(ya-yc)*(xa-xb));
return o;
}
inline double get_out_r(point p[]){
double a = dis(p[0],p[1]),b = dis(p[1],p[2]),c = dis(p[2],p[0]),s = trarea(p);
return a*b*c/sqr(4*s);
}
point must_on[3],p[maxn];
circle mc;
inline void get_circle(int tm){
switch(tm){
case 0:mc.r = -1;
break;
case 1:mc.r = 0,mc.c = must_on[0];
break;
case 2:{
mc.r = dis(must_on[0],must_on[1])/4.0;
mc.c.x = (must_on[0].x+must_on[1].x)/2.0;
mc.c.y = (must_on[0].y + must_on[1].y)/2.0;
}break;
case 3:{
mc.r = get_out_r(must_on);
mc.c = get_out_circle(must_on);
}break;
}
}
inline void min_circle(int t,int ton){
get_circle(ton);
if(ton >= 3)return;
for(int i = 0; i < t; ++i){
if(p[i].flag == 1){
if(dis(mc.c,p[i]) > mc.r + EPS){
must_on[ton] = p[i];
min_circle(i,ton+1);
}
}
else {
if(dis(mc.c,p[i]) + EPS < mc.r){
must_on[ton] = p[i];
min_circle(i,ton+1);
}
}
}
}
int main(){
int n,m;
while (scanf("%d%d",&n,&m) != EOF){
for(int i = 0; i < n; ++i){
scanf("%lf%lf",&p[i].x,&p[i].y);
p[i].flag = 1;
}
for(int i = n; i < m + n; ++i){
scanf("%lf%lf",&p[i].x,&p[i].y);
p[i].flag = 2;
}
n = n + m;
random_shuffle(p,p+n);
min_circle(n,0);
printf("%.3lf %.3lf\n%.3lf\n",mc.c.x,mc.c.y,sqrt(mc.r));
}
return 0;
}

111
HDOJ/3996_autoAC.cpp Normal file
View File

@ -0,0 +1,111 @@
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=62002;
const int M=62002;
const __int64 INF=1LL<<60;
int t,n,m,tot,cas=1;
int gap[M],dis[M],pre[M],head[N],cur[N],vis[N];
int NE,NV,sink,source;
struct Node
{
__int64 c;
int pos,next;
} E[9999999];
#define FF(i,NV) for(int i=0;i<NV;i++)
__int64 sap(int s,int t)
{
memset(dis,0,sizeof(int)*(NV+1));
memset(gap,0,sizeof(int)*(NV+1));
FF(i,NV) cur[i] = head[i];
int u = pre[s] = s;
__int64 maxflow = 0,aug =INF;
gap[0] = NV;
while(dis[s] < NV)
{
loop:
for(int &i = cur[u]; i != -1; i = E[i].next)
{
int v = E[i].pos;
if(E[i].c && dis[u] == dis[v] + 1)
{
if(aug>E[i].c) aug=E[i].c;
pre[v] = u;
u = v;
if(v == t)
{
maxflow += aug;
for(u = pre[u]; v != s; v = u,u = pre[u])
{
E[cur[u]].c -= aug;
E[cur[u]^1].c += aug;
}
aug =INF;
}
goto loop;
}
}
if( (--gap[dis[u]]) == 0) break;
int mindis = NV;
for(int i = head[u]; i != -1 ; i = E[i].next)
{
int v = E[i].pos;
if(E[i].c >0&& mindis > dis[v])
{
cur[u] = i;
mindis = dis[v];
}
}
gap[ dis[u] = mindis+1 ] ++;
u = pre[u];
}
return maxflow;
}
void addEdge(int u,int v,__int64 c )
{
E[NE].c = c;
E[NE].pos = v;
E[NE].next = head[u];
head[u] = NE++;
E[NE].c = 0;
E[NE].pos = u;
E[NE].next = head[v];
head[v] = NE++;
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
int i,j,a,b,w,cost,val;
__int64 sum=0;
source=0,sink=3000,NE=0,NV=sink+1;
memset(head,-1,sizeof(int)*(NV));
for(int i=1; i<=n; i++)
{
scanf("%d",&m);
for(int j=1; j<=m; j++)
{
scanf("%d%d%d",&cost,&val,&w);
val-=cost;
if(val>0)
{
addEdge(source,i*26+j,val);
sum+=val;
}
else addEdge(i*26+j,sink,-val);
while(w--)
{
scanf("%d%d",&a,&b);
addEdge(i*26+j,a*26+b,INF);
}
}
}
__int64 ans=sap(source,sink);
printf("Case #%d: %I64d\n",cas++,sum-ans);
}
return 0;
}

100
HDOJ/3998_autoAC.cpp Normal file
View File

@ -0,0 +1,100 @@
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std ;
const int INF=0xfffffff ;
struct node
{
int s,t,cap,nxt ;
}e[400005] ;
int m,n,cnt,head[100005],level[100005],q[100005] ;
void add(int s,int t,int cap)
{
e[cnt].s=s ;e[cnt].t=t ;e[cnt].cap=cap ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;
e[cnt].s=t ;e[cnt].t=s ;e[cnt].cap=0 ;e[cnt].nxt=head[t] ;head[t]=cnt++ ;
}
bool build(int s,int t)
{
int front=0,rear=0 ;
memset(level,-1,sizeof(level)) ;
q[rear++]=s ;
level[s]=1 ;
while(front<rear)
{
int u=q[front++] ;
for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
{
int tt=e[i].t ;
if(level[tt]==-1 && e[i].cap>0)
{
level[tt]=level[u]+1 ;
if(tt==t)return true ;
q[rear++]=tt ;
}
}
}
return false ;
}
int find(int s,int t,int flow)
{
if(s==t)return flow ;
int ret=0,a ;
for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
{
int tt=e[i].t ;
if(level[tt]==level[s]+1 && e[i].cap>0)
{
a=find(tt,t,min(e[i].cap,flow-ret)) ;
e[i].cap-=a ;
e[i^1].cap+=a ;
ret+=a ;
if(ret==flow)
return ret ;
}
}
if(!ret)level[s]=-1 ;
return ret ;
}
int dinic(int s,int t)
{
int flow,ret=0 ;
while(build(s,t))
while(flow=find(s,t,INF))
ret+=flow ;
return ret ;
}
int a[1005],dp[1005] ;
int main()
{
while(~scanf("%d",&n))
{
for(int i=1 ;i<=n ;i++)
scanf("%d",&a[i]) ;
int ans=0 ;
for(int i=1 ;i<=n ;i++)
{
dp[i]=1 ;
for(int j=1 ;j<i ;j++)
if(a[j]<a[i] && dp[j]+1>dp[i])
dp[i]=dp[j]+1 ;
ans=max(ans,dp[i]) ;
}
int S,T ;
S=0 ;T=2*n+1 ;
cnt=0 ;
memset(head,-1,sizeof(head)) ;
for(int i=1 ;i<=n ;i++)
{
add(i,i+n,1) ;
if(dp[i]==1)add(S,i,1) ;
if(dp[i]==ans)add(i+n,T,1) ;
for(int j=i+1 ;j<=n ;j++)
{
if(dp[j]==dp[i]+1)
add(i+n,j,1) ;
}
}
printf("%d\n%d\n",ans,dinic(S,T)) ;
}
return 0 ;
}

66
HDOJ/3999_autoAC.cpp Normal file
View File

@ -0,0 +1,66 @@
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct node{
int num;
struct node *left;
struct node *right;
}*tree;
int tot=0;
node *build(node *root,int num)
{
if(root==NULL)
{
root=new node;
root->left=NULL;
root->right=NULL;
root->num=num;
return root;
}
else
{
int t=root->num-num;;
if(t>0)
root->left=build(root->left,num);
else
root->right=build(root->right,num);
return root;
}
}
bool first;
void visit(node *root)
{
if(root!=NULL&&!first)
printf(" %d",root->num);
else
{
first=false;
printf("%d",root->num);
}
}
void preorder(node *root)
{
if(root!=NULL)
{
visit(root);
preorder(root->left);
preorder(root->right);
}
}
int main()
{
int n,num;
while(scanf("%d",&n)!=EOF)
{
first=true;
int num;
for(int i=1;i<=n;i++)
{
scanf("%d",&num);
tree=build(tree,num);
}
preorder(tree);
puts("");
}
return 0;
}