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 
4800-4899
This commit is contained in:
KiritoTRw 2016-09-10 11:32:44 +08:00 committed by GitHub
parent 54568ca2fa
commit 1b77522684
74 changed files with 7060 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
HDOJ/4800_autoAC.cpp Normal file
View File

@ -0,0 +1,62 @@
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define N 10005
int m,n;
int ai[N];
double dp[200][N],rate[200][200];
bool vis[200][N];
double search(int team,int lo)
{
if(lo>m-1||team<0||team>n)
return 1;
if(vis[team][lo]==true)
return dp[team][lo];
else
{
double t=search(team,lo+1);
if(team!=ai[lo])
{
double t2=search(ai[lo],lo+1);
if(t2>t)
t=t2;
}
vis[team][lo]=true;
dp[team][lo]=rate[team][ai[lo]]*t;
return dp[team][lo];
}
}
int main()
{
int i,j;
while(scanf("%d",&n)!=EOF)
{
n=n*(n-1)*(n-2);
n/=6;
for(i=0;i<n;i++){
for(j=0;j<n;j++)
{
scanf("%lf",&rate[i][j]);
}
}
scanf("%d",&m);
for(i=0;i<m;i++)
scanf("%d",&ai[i]);
memset(vis,false,sizeof(vis));
for(i=0;i<n;i++)
{
dp[i][m-1]=rate[i][ai[m-1]];
vis[i][m-1]=true;
}
double _max=0;
for(i=0;i<n;i++)
{
_max=max(_max,search(i,0));
}
printf("%.6lf\n",_max);
}
return 0;
}

49
HDOJ/4801_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cmath>
#include <algorithm>
using namespace std;
int B[6][24]={ {6,1,12,3,5,11,16,7,8,9,4,10,18,13,14,15,20,17,22,19,0,21,2,23}, //ok
{20,1,22,3,10,4,0,7,8,9,11,5,2,13,14,15,6,17,12,19,16,21,18,23}, //ok
{1,3,0,2,23,22,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,21,9,8}, //ok
{2,0,3,1,6,7,8,9,23,22,10,11,12,13,14,15,16,17,18,19,20,21,5,4}, //ok
{0,1,8,14,4,3,7,13,17,9,10,2,6,12,16,15,5,11,18,19,20,21,22,23}, //ok
{0,1,11,5,4,16,12,6,2,9,10,17,13,7,3,15,14,8,18,19,20,21,22,23} //ok
};
int ans;
void update(int *h)
{
int sum=0;
if (h[0]==h[1] && h[1]==h[2] && h[2]==h[3]) sum++;
if (h[4]==h[5] && h[5]==h[10] && h[10]==h[11]) sum++;
if (h[6]==h[7] && h[7]==h[12] && h[12]==h[13]) sum++;
if (h[8]==h[9] && h[9]==h[14] && h[14]==h[15]) sum++;
if (h[16]==h[17] && h[17]==h[18] && h[18]==h[19]) sum++;
if (h[20]==h[21] && h[21]==h[22] && h[22]==h[23]) sum++;
ans=max(ans,sum);
}
void dfs(int N,int *h)
{
update(h);
if (!N) return;
int k,i,p[24];
for (k=0;k<6;k++)
{
for (i=0;i<24;i++) p[i]=h[B[k][i]];
dfs(N-1,p);
}
return;
}
int main()
{
int N,i,h[24];
while (~scanf("%d",&N))
{
for (i=0;i<24;i++) scanf("%d",&h[i]);
ans=0;
dfs(N,h);
printf("%d\n",ans);
}
return 0;
}

33
HDOJ/4802_autoAC.cpp Normal file
View File

@ -0,0 +1,33 @@
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
map<string,double>m;
double s,sum1,sum2;
string op;
int n;
int main()
{
m["A"]=4.0,m["A-"]=3.7,m["B+"]=3.3,m["B"]=3.0;
m["B-"]=2.7,m["C+"]=2.3,m["C"]=2.0,m["C-"]=1.7;
m["D"]=1.3,m["D-"]=1.0,m["F"]=0;
while(cin>>n)
{
sum1=0,sum2=0;
for(int i=0;i<n;i++)
{
cin>>s>>op;
if(op=="P"||op=="N")
continue;
sum2+=s;
sum1+=s*m[op];
}
if(sum2==0)
printf("0.00\n");
else
printf("%.2lf\n",sum1/sum2);
}
}

59
HDOJ/4803_autoAC.cpp Normal file
View File

@ -0,0 +1,59 @@
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
int x,y;
int main()
{
while(~scanf("%d%d",&x,&y))
{
if(y<x) printf("-1\n");
else if(x==1) printf("%d\n",y-1);
else
{
if(x==2)
printf("%d\n",(y+1)/2);
else if(x==3)
{
int a[3]={2,3,4};
printf("%d\n",(y-3)/3+a[(y-3)%3]);
}
else if(x==4)
{
int a[4]={3,4,4,5};
printf("%d\n",(y-4)/4+a[(y-4)%4]);
}
else if(x==5)
{
int a[5]={4,5,5,6,6};
printf("%d\n",(y-5)/5+a[(y-5)%5]);
}
else if(x==6)
{
int a[]={5,6,6,6,7,7};
printf("%d\n",(y-6)/6+a[(y-6)%6]);
}
else if(x==7)
{
int a[7]={6,7,7,7,8,8,9};
printf("%d\n",(y-7)/7+a[(y-7)%7]);
}
else if(x==8)
{
int a[8]={7,8,8,9,8,9,9,10};
printf("%d\n",(y-8)/8+a[(y-8)%8]);
}
else if(x==9)
{
int a[9]={8,9,9,9,9,10,10,10,11};
printf("%d\n",(y-9)/9+a[(y-9)%9]);
}
else if(x==10)
{
int a[10]={9,10,10,10,11,10,11,11,11,12};
printf("%d\n",(y-10)/10+a[(y-10)%10]);
}
}
}
}

49
HDOJ/4804_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
const int MOD = 1000000007;
int n, m, c, d, pre = 0, now = 1;
long long dp[2][25][1222];
char g[105][15];
int main() {
while (~scanf("%d%d%d%d", &n, &m, &c, &d)) {
int maxs = (1<<m);
memset(dp[now], 0, sizeof(dp[now]));
dp[now][0][maxs - 1] = 1;
for (int i = 0; i < n; i++)
scanf("%s", g[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
swap(pre, now);
memset(dp[now], 0, sizeof(dp[now]));
int tmp = g[i][j] - '0';
if (tmp) {
for (int k = 0; k <= d; k++) {
for (int s = 0; s < maxs; s++) {
if (k && (s&1<<j))
dp[now][k][s] = (dp[now][k][s] + dp[pre][k - 1][s]) % MOD;
if (j && !(s&1<<(j-1)) && (s&1<<j))
dp[now][k][s|1<<(j-1)] = (dp[now][k][s|1<<(j-1)] + dp[pre][k][s]) % MOD;
dp[now][k][s^1<<j] = (dp[now][k][s^1<<j] + dp[pre][k][s]) % MOD;
}
}
}
else {
for (int k = 0; k <= d; k++) {
for (int s = 0; s < maxs; s++) {
if ((s&1<<j))
dp[now][k][s] = (dp[now][k][s] + dp[pre][k][s]) % MOD;
}
}
}
}
}
long long ans = 0;
for (int i = c; i <= d; i++)
ans = (ans + dp[now][i][maxs - 1]) % MOD;
printf("%lld\n", ans);
}
return 0;
}

174
HDOJ/4805_autoAC.cpp Normal file
View File

@ -0,0 +1,174 @@
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <sstream>
#include <iostream>
#include <algorithm>
using namespace std;
#define PB push_back
#define MP make_pair
#define AA first
#define BB second
#define OP begin()
#define ED end()
#define SZ size()
#define SORT(x) sort(x.OP,x.ED)
#define SQ(x) ((x)*(x))
#define SSP system("pause")
#define cmin(x,y) x=min(x,y)
#define cmax(x,y) x=max(x,y)
typedef long long LL;
typedef pair<int, int> PII;
const double eps=1e-8;
const double PI=acos(-1.);
const LL MOD = 1000000007;
int sign(double x) {return x<-eps?-1:x>eps;}
struct spt {
double x,y,z;
spt(double _x=0,double _y=0,double _z=0) :x(_x),y(_y),z(_z) {}
spt operator + (spt s) {return spt(x+s.x,y+s.y,z+s.z);}
spt operator - (spt s) {return spt(x-s.x,y-s.y,z-s.z);}
spt operator * (double s) {return spt(x*s,y*s,z*s);}
spt operator / (double s) {return spt(x/s,y/s,z/s);}
double len() const {return sqrt(SQ(x)+SQ(y)+SQ(z));}
double operator * (spt s) {return x*s.x+y*s.y+z*s.z;}
spt operator ^ (spt s) {
spt ret;
ret.x=y*s.z-z*s.y;
ret.y=z*s.x-x*s.z;
ret.z=x*s.y-y*s.x;
return ret;
}
void output(char *s="") {printf("%s:%.6f %.6f %.6f\n",s,x,y,z);}
void input() {scanf("%lf%lf%lf",&x,&y,&z);}
} Orz(0,0,0);
spt S,T,V,A,B,C;
double disLP(spt p1,spt p2,spt q) {
return fabs((p2-p1)*(q-p1)/(p2-p1).len());
}
double disLL(spt p1,spt p2,spt q1,spt q2) {
spt p=q1-p1,u=p2-p1,v=q2-q1;
double d=(u*u)*(v*v)-SQ(u*v);
if(sign(d)==0)return disLP(q1,q2,p1);
double s=((p*u)*(v*v)-(p*v)*(u*v))/d;
return disLP(q1,q2,p1+u*s);
}
int isFL(spt p,spt o,spt q1,spt q2,spt &is) {
double a=o*(q2-p),b=o*(q1-p);
double d=a-b;
if(sign(d)==0)return 0;
is=(q1*a-q2*b)/d;
return 1;
}
int isFF(spt p1,spt o1,spt p2,spt o2,spt &ip,spt &io) {
spt e=o1^o2;
spt v=o1^e;
double d=o2*v;
if(sign(d)==0)return 0;
ip=p1+v*(o2*(p2-p1))/d,io=e;
return 1;
}
int inner(spt O,spt A,spt B,spt C) {
double S=((B-A)^(C-A)).len();
double S1=((A-O)^(B-O)).len();
double S2=((A-O)^(C-O)).len();
double S3=((C-O)^(B-O)).len();
return sign(S-S1-S2-S3)==0;
}
int inner(double o,double a,double b) {
return sign(max(a,b)-o)>=0&&sign(min(a,b)-o)<=0;
}
int inner(spt O,spt A,spt B) {
return inner(O.x,A.x,B.x)&&inner(O.y,A.y,B.y)&&inner(O.z,A.z,B.z);
}
int main() {
int i,j,k,u,v,w,p,q,r,n,m;
while(~scanf("%d",&n)) {
S.input(),T.input();
V.input();
double ans=0;
spt U= (S-T) ^V;
for(j=0; j<n; j++) {
A.input(),B.input(),C.input();
spt D= (B-A) ^ (C-A);
if(sign(D.len()) ==0) continue;
if(sign(U.len())==0) {
spt is;
int f=isFL(A,D,S,S+V,is);
if(f) {
ans+=inner(is,A,B,C);
continue;
}
if(sign((S-A)*D))continue;
spt iAB,iBC,iAC;
int fAB=isFL(A,D^(A-B),S,S+V,iAB);
int fBC=isFL(B,D^(B-C),S,S+V,iBC);
int fAC=isFL(C,D^(C-A),S,S+V,iAC);
fAB&=inner(iAB,A,B);
fBC&=inner(iBC,B,C);
fAC&=inner(iAC,A,C);
ans+=fAB|fBC|fAC;
continue;
}
if(sign(V*D)==0) {
if(sign((S-A)*D)==0&&sign((T-A)*D)==0) {
//TODO V//ABC && STABC on flat
spt iA,iB,iC;
int fA=isFL(S,(T-S)^D,A,A+V,iA);
int fB=isFL(S,(T-S)^D,B,B+V,iB);
int fC=isFL(S,(T-S)^D,C,C+V,iC);
double len=(T-S).len();
double le=0,re=len;
vector<double>L;
if(fA)L.PB((iA-S)*(T-S)/len);
if(fB)L.PB((iB-S)*(T-S)/len);
if(fC)L.PB((iC-S)*(T-S)/len);
sort(L.OP,L.ED);
if(L.SZ<2)continue;
double pe=L[0],qe=L[L.SZ-1];
cmax(pe,le);
cmin(qe,re);
if(qe>pe)ans+=(qe-pe)/len;
}
continue;
}
spt SP,TP,iAB,iBC,iAC;
assert(isFL(A,D,S,S+V,SP));
assert(isFL(A,D,T,T+V,TP));
if(inner(SP,A,B,C)&&inner(TP,A,B,C)) {ans+=1; continue;}
vector<spt>L;
L.PB(SP),L.PB(TP);
int fAB=isFL(A,D^(A-B),SP,TP,iAB);
int fBC=isFL(B,D^(B-C),SP,TP,iBC);
int fAC=isFL(C,D^(C-A),SP,TP,iAC);
double len=(SP-TP).len();
if(fAB&&inner(iAB,SP,TP))for(i=0; i+1<L.SZ; i++)
if(inner(iAB,L[i],L[i+1])) {L.insert(L.OP+i+1,iAB); break;}
if(fBC&&inner(iBC,SP,TP))for(i=0; i+1<L.SZ; i++)
if(inner(iBC,L[i],L[i+1])) {L.insert(L.OP+i+1,iBC); break;}
if(fAC&&inner(iAC,SP,TP))for(i=0; i+1<L.SZ; i++)
if(inner(iAC,L[i],L[i+1])) {L.insert(L.OP+i+1,iAC); break;}
for(i=0; i+1<L.SZ; i++) {
spt mid=(L[i]+L[i+1])/2;
if(inner(mid,A,B,C))
ans+=(L[i+1]-L[i]).len()/len;
}
}
printf("%.8f\n",ans);
}
return 0;
}

93
HDOJ/4807_autoAC.cpp Normal file
View File

@ -0,0 +1,93 @@
#include<stdio.h>
#include<string.h>
#include<queue>
#include<math.h>
#define N_node 2500 + 50
#define N_edge 10000 + 100
#define INF 2000000000
using namespace std;
typedef struct
{
int from ,to ,next ,cost ,flow;
}STAR;
STAR E[N_edge];
int list[N_node] ,tot;
int mer[N_edge] ,s_x[N_node];
void add(int a ,int b ,int c ,int d)
{
E[++tot].from = a;
E[tot].to = b;
E[tot].cost = c;
E[tot].flow = d;
E[tot].next = list[a];
list[a] = tot;
}
bool spfa(int s ,int t ,int n)
{
int mark[N_node] = {0};
for(int i = 0 ;i <= n ;i ++)
s_x[i] = INF;
queue<int>q;
q.push(s);
mark[s] = 1 ,s_x[s] = 0;
memset(mer ,255 ,sizeof(mer));
while(!q.empty())
{
int xin ,tou;
tou = q.front();
q.pop();
mark[tou] = 0;
for(int k = list[tou] ;k ;k = E[k].next)
{
xin = E[k].to;
if(s_x[xin] > s_x[tou] + E[k].cost && E[k].flow)
{
s_x[xin] = s_x[tou] + E[k].cost;
mer[xin] = k;
if(!mark[xin])
{
mark[xin] = 1;
q.push(xin);
}
}
}
}
return mer[t] != -1;
}
int M_C_Flow(int s ,int t ,int n ,int k)
{
if(!k) return 0;
int minflow ,sum_peo = k ,now_peo = 0 ,list_time = 0 ,ans = INF;
while(spfa(s ,t ,n))
{
minflow = INF;
for(int i = mer[t] ;i + 1 ;i = mer[E[i].from])
if(minflow > E[i].flow) minflow = E[i].flow;
for(int i = mer[t] ;i + 1 ;i = mer[E[i].from])
E[i].flow -= minflow ,E[i^1].flow += minflow;
sum_peo -= (s_x[t] - list_time) * now_peo + minflow;
list_time = s_x[t] ,now_peo += minflow;
int now = s_x[t] + (int)ceil((1.0 * (sum_peo < 0 ? 0 : sum_ ))/now_peo);
if(ans > now) ans = now;
if(sum_peo < 1) break;
}
return ans;
}
int main ()
{
int n ,m ,k ,i ,a ,b ,c;
while(~scanf("%d %d %d" ,&n ,&m ,&k))
{
memset(list ,0 ,sizeof(list));
tot = 1;
for(i = 1 ;i <= m ;i ++)
{
scanf("%d %d %d" ,&a ,&b ,&c);
a ++ ,b ++;
add(a ,b ,1 ,c) ,add(b ,a ,-1 ,0);
}
int ans = M_C_Flow(1 ,n ,n ,k);
ans == INF ? puts("No solution"):printf("%d\n" ,ans);
}
return 0;
}

17
HDOJ/4808_autoAC.cpp Normal file
View File

@ -0,0 +1,17 @@
#include <cstdio>
#include <cmath>
const int MAXN = 200000 + 5;
double t[MAXN];
int main()
{
t[0] = acos(-1) / 2., t[1] = 1.;
for (int i = 2; i < MAXN; ++ i) {
t[i] = t[i - 2] * (i - 1) / i;
}
int n, R;
while (scanf("%d%d", &n, &R) == 2) {
double res = .5 * t[n + 1] * R / t[2];
printf("%.10lf\n", res);
}
return 0;
}

91
HDOJ/4809_autoAC.cpp Normal file
View File

@ -0,0 +1,91 @@
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <climits>
#include <ctime>
#include <cmath>
#include <set>
#include <map>
#include <string>
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define abs(x) ((x)>0?(x):(-(x)))
#define FOR(i,a,b) for(int i = (a);i<=(b);i++)
#define FORD(i,a,b) for(int i = (a);i>=(b);i--)
#define REP(i,n) for(int i = 0;i<(n);i++)
#define rst(x,k) memset(x,k,sizeof(x))
#define lowbit(x) ((x)&(-(x)))
#define h(x) (1<<(x))
#define lson (ind<<1)
#define rson (ind<<1|1)
#define eps 1e-6
#define maxn 480
#define INF 1000000000
#define mod 1000000007LL
#define base 160
#define link fsafsdfas
using namespace std;
typedef long long LL;
struct node{
int t,nxt;
}edge[maxn<<1];
int headline[maxn],E;
void add(int f,int t){
edge[E].t = t;
edge[E].nxt = headline[f];
headline[f] = E++;
}
LL dp[310][3][480];
LL tt[310][3][480];
int n;
int high[310],low[310];
int up,down;
void dfs(int u,int fa){
dp[u][0][base] = 2;
dp[u][1][base] = 1;
high[u] = low[u] = 0;
for(int i = headline[u];~i;i = edge[i].nxt){
int v = edge[i].t; if(v == fa)continue;
dfs(v,u);rst(tt[u],0);
FOR(p,low[u],high[u]){
FOR(q,low[v]-1,high[v]+1){
if((p+q > n) || (p+q < (-n)/2-2))continue;
tt[u][0][p+q+base] += dp[u][0][p+base]*dp[v][0][q+base] + dp[u][0][p+base]*dp[v][1][q+base-1] + dp[u][0][p+base]*dp[v][2][q+base+1];
tt[u][1][p+q+base] += dp[u][1][p+base]*dp[v][0][q+base] + dp[u][1][p+base]*dp[v][2][q+base] + dp[u][2][p+base]*dp[v][1][q+base];
tt[u][2][p+q+base] += dp[u][1][p+base]*dp[v][1][q+base] + dp[u][2][p+base]*dp[v][0][q+base] + dp[u][2][p+base]*dp[v][2][q+base];
tt[u][0][p+q+base] %= mod; if(tt[u][0][p+q+base] && p+q > high[u]) high[u] = p+q; if(tt[u][0][p+q+base] && p+q < low[u])low[u] = p+q;
tt[u][1][p+q+base] %= mod; if(tt[u][1][p+q+base] && p+q > high[u]) high[u] = p+q; if(tt[u][1][p+q+base] && p+q < low[u])low[u] = p+q;
tt[u][2][p+q+base] %= mod; if(tt[u][2][p+q+base] && p+q > high[u]) high[u] = p+q; if(tt[u][2][p+q+base] && p+q < low[u])low[u] = p+q;
}
}
FOR(j,low[u],high[u]){
dp[u][0][j+base] = tt[u][0][j+base];
dp[u][1][j+base] = tt[u][1][j+base];
dp[u][2][j+base] = tt[u][2][j+base];
}
}
}
void solve(){
rst(headline,-1); E = 0;
rst(dp,0);
REP(i,n-1){
int a,b; scanf("%d%d",&a,&b);
add(a,b); add(b,a);
}
up = n; down = -n/2-1;
dfs(1,0);
LL ans = 0;
FOR(i,-1,up){
ans += dp[1][0][i+base]*(MAX(i,0))%mod;
ans += dp[1][1][i+base]*(MAX(i+1,0))%mod;
ans += dp[1][2][i+base]*(MAX(i-1,0))%mod;
ans %= mod;
}
printf("%I64d\n",ans*3%mod);
}
int main(void){
while(EOF != scanf("%d",&n))solve();
return 0;
}

63
HDOJ/4810_autoAC.cpp Normal file
View File

@ -0,0 +1,63 @@
#include<stdio.h>
#include<string.h>
#include<map>
#include<algorithm>
using namespace std;
#define mod 1000003
int n;
int a[1001];
long long ans[1001];
int sum;
long long c[1001][1001];
int num[33];
inline void init()
{
memset(c,0,sizeof(c));
c[0][0]=1;
for(int i=1;i<=1000;i++) c[i][0]=1,c[i][i]=1;
for(int i=2;i<=1000;i++)
for(int j=1;j<i;j++)
c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;
}
inline void chuli(int t)
{
int val=t;
int s=1;
while(val)
{
if(val%2)
num[s]++;
val/=2;
s++;
}
}
int main()
{
init();
while(~scanf("%d",&n))
{
memset(ans,0,sizeof(ans));
memset(num,0,sizeof(num));
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
chuli(a[i]);
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=32;j++)
{
for(int k=1;k<=i;k+=2)
ans[i]+=(c[num[j]][k]*(c[n-num[j]][i-k])%mod)*((1*1LL)<<(j-1) %mod),ans[i]%=mod;
}
}
for(int i=1;i<=n;i++)
{
printf("%I64d",ans[i]%mod);
if(i==n)
printf("\n");
else
printf(" ");
}
}
}

60
HDOJ/4811_autoAC.cpp Normal file
View File

@ -0,0 +1,60 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
long long a[3];
int main()
{
while(~scanf("%I64d%I64d%I64d",&a[0],&a[1],&a[2]))
{
long long n=a[0]+a[1]+a[2];
sort(a,a+3);
if(a[2]==0)
printf("0\n");
else if(a[1]==0)
{
if(a[2]==1)
printf("0\n");
else
printf("%I64d\n",1+(n-2)*2);
}
else if(a[0]==0)
{
if(a[1]==1)
{
if(a[2]==1)
printf("1\n");
else
printf("%I64d\n",1+2+(n-3)*3);
}
else
printf("%I64d\n",1+2+3+(n-4)*4);
}
else
{
if(a[0]>=2)
{
printf("%I64d\n",15+(n-6)*6);
}
else if(a[0]==1)
{
if(a[1]==1)
{
if(a[2]==1)
{
printf("%I64d\n",1*1LL+2);
}
else
{
printf("%I64d\n",1+2+3+(a[2]-2)*4);
}
}
else
{
printf("%I64d\n",1+2+3+4+(n-5)*5);
}
}
}
}
return 0;
}

110
HDOJ/4812_autoAC.cpp Normal file
View File

@ -0,0 +1,110 @@
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define clr( x , y ) memset(x,y,sizeof(x))
#define sqr(x) ((x) * (x))
#define mp make_pair
#define pb push_back
#define x first
#define y second
typedef long long lint;
#pragma comment(linker,"/STACK:102400000,102400000")
const int mm = 1000003;
const lint qq = 100000;
int n , m , q = 0 , d[100100] , s[100100] , mx[100100];
vector < int > a[100100];
lint f[1001000] , p[1001000];
bool v[100100];
pair < int , int > ans , as = mp( 100000000 , 100000000 );
void MX(pair < int , int > k) {
if ( k.x > k.y ) swap( k.x , k.y );
if ( k < ans ) ans = k;
}
int find(int t)
{
int k = mm - 2 , s = 1;
while ( k ) {
if ( k & 1 ) s = (lint) s * t % mm;
t = (lint) t * t % mm;
k >>= 1;
}
return s;
}
void init()
{
int x , y;
rep(i,1,n) scanf("%d",&d[i]) , v[i] = 1 , a[i].clear();
rep(i,2,n) {
scanf("%d%d",&x,&y);
a[x].pb( y );
a[y].pb( x );
}
ans = as;
}
void fdfs(int t,int fa)
{
s[t] = 1; mx[t] = 0;
red(i,a[t].size()-1,0) if ( a[t][i] != fa && v[a[t][i]] ) {
fdfs( a[t][i] , t );
s[t] += s[a[t][i]];
mx[t] = max( mx[t] , s[a[t][i]] );
}
}
int froot(int t,int m)
{
int x = t , y;
mx[t] = max( mx[t] , m - s[t] );
red(i,a[t].size()-1,0) if ( v[a[t][i]] && s[t] > s[a[t][i]] ) {
y = froot( a[t][i] , m );
if ( mx[y] < mx[x] ) x = y;
}
return x;
}
void dfs(int t,int fa,lint s,int k)
{
s = s * d[t] % mm;
if ( k ) {
lint x = f[p[s]*m%mm] - q * qq;
if ( x > 0 ) MX( mp( (int)x , t ) );
} else {
lint x = q * qq + t;
if ( f[s] < q * qq || f[s] > x ) f[s] = x;
}
red(i,a[t].size()-1,0) if ( v[a[t][i]] && a[t][i] != fa ) dfs( a[t][i] , t , s , k );
}
void work()
{
rep(i,1,n) while ( v[i] ) {
fdfs( i , 0 );
int x = froot( i , s[i] );
v[x] = 0;
q ++;
f[d[x]] = q * qq + x;
red(j,a[x].size()-1,0) if ( v[a[x][j]] ) {
dfs( a[x][j] , x , 1 , 1 );
dfs( a[x][j] , x , d[x] , 0 );
}
}
if ( ans == as ) puts("No solution"); else printf("%d %d\n",ans.x,ans.y);
}
int main()
{
rep(i,1,mm) p[i] = find( i );
while ( cin >> n >> m ) {
init();
work();
}
return 0;
}

20
HDOJ/4813_autoAC.cpp Normal file
View File

@ -0,0 +1,20 @@
#include<stdio.h>
#include<string.h>
char s[1000005];
int main(){
int t,n,m,i,j;
scanf("%d",&t);
while(t--){
scanf("%d%d",&n,&m);
scanf("%s",s);
for(i=0,j=0;i<n*m;i++){
printf("%c",s[i]);
j++;
if(j==m){
printf("\n");
j=0;
}
}
}
return 0;
}

93
HDOJ/4814_autoAC.cpp Normal file
View File

@ -0,0 +1,93 @@
#include <cstdio>
#include <cstring>
#define LEN 100
#define HLE 50
using namespace std;
typedef struct fbn {
int a[LEN];
int pn;
void init() {
memset(a, 0, sizeof(a));
pn = 0;
}
void print() {
bool b = false;
for (int i = 0; i < HLE; i++) {
if (a[i] != 0) b = true;
if (b == true) printf("%d", a[i]);
}
if (pn != 0) {
printf(".");
for (int i = 0; i < pn; i++)
printf("%d", a[i + HLE]);
}
printf("\n");
}
}FBN;
bool check(FBN a)
{
bool t = true;
for (int i = 0; i < LEN; i++) {
if (a.a[i] > 1) {t = false; break;}
if ((i != LEN - 1) && a.a[i] == 1 && a.a[i + 1] == 1) {t = false; break;}
}
return t;
}
FBN normalize(FBN a)
{
int t;
do {
for (int i = 0; i < LEN; i++) {
if (a.a[i] > 1) {
t = a.a[i] / 2;
a.a[i] %= 2;
a.a[i - 1] += 1;
a.a[i + 2] += 1;
}
if ((i != LEN - 1) && a.a[i] == 1 && a.a[i + 1] == 1) {
a.a[i - 1] += 1;
a.a[i] = 0;
a.a[i + 1] = 0;
}
}
} while (!check(a));
for (int i = LEN - 1; i >= HLE; i--) {
if (a.a[i] != 0) {
a.pn = i - HLE + 1;
break;
}
}
return a;
}
FBN add(FBN a, FBN b)
{
FBN ans;
ans.init();
for (int i = 0; i < LEN; i++) {
ans.a[i] = a.a[i] + b.a[i];
}
ans = normalize(ans);
return ans;
}
int main()
{
int n, i;
FBN twob[30], ans;
for (i = 0; i < 30; i++) twob[i].init();
twob[0].a[HLE - 1] = 1;
twob[0].pn = 0;
for (i = 1; i < 30; i++) {
twob[i] = add(twob[i - 1], twob[i - 1]);
}
while (scanf("%d", &n) != EOF) {
i = 0;
ans.init();
while (n > 0) {
if ((n & 1) == 1) ans = add(ans, twob[i]);
n >>= 1;
i++;
}
ans.print();
}
return 0;
}

37
HDOJ/4815_autoAC.cpp Normal file
View File

@ -0,0 +1,37 @@
#include <iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;
int dp[40100],po[50];
long long need,all;
int main()
{
int n,i,j,t,sum;
double p;
scanf("%d",&t);
while(t--)
{
need=sum=all=0;
scanf("%d%lf",&n,&p);
for(i=0;i<n;i++)
scanf("%d",&po[i]),sum+=po[i];
memset(dp,0,sizeof dp);
dp[0]=1,all=1LL<<n;
for(i=0;i<n;i++)
for(j=sum;j>=po[i];j--)
if(dp[j-po[i]])
dp[j]+=dp[j-po[i]];
need=ceil(all*p);
for(i=0,all=0;i<=sum;i++)
{
all+=dp[i];
if(all>=need)
{
printf("%d\n",i);
break;
}
}
}
return 0;
}

111
HDOJ/4816_autoAC.cpp Normal file
View File

@ -0,0 +1,111 @@
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <math.h>
using namespace std;
const int MAXN = 200010;
int x[MAXN],y[MAXN];
int d;
int n;
int L;
int nowx ;
int nextx;
int r1,l2;
const double eps = 1e-8;
double solve()
{
double left = nowx,right = nextx;
double ret1,ret2;
for(int cc = 0;cc <= 30;cc++)
{
double mid = (left + right)/2;
double midmid = (mid + right)/2;
double h1 = y[r1] + (double)(y[r1-1] - y[r1]) * (mid - x[r1])/(x[r1-1] - x[r1]);
double h2 = y[l2] + (double)(y[l2+1] - y[l2])*(mid + 2*d - x[l2])/(x[l2 + 1] - x[l2]);
ret1 = (double)(x[r1] - mid)*(h1 + y[r1])/2 + (double)(mid + 2*d - x[l2])*(h2 + y[l2])/2;
h1 = y[r1] + (double)(y[r1-1] - y[r1]) * (midmid - x[r1])/(x[r1-1] - x[r1]);
h2 = y[l2] + (double)(y[l2+1] - y[l2])*(midmid + 2*d - x[l2])/(x[l2 + 1] - x[l2]);
ret2 = (double)(x[r1] - midmid)*(h1 + y[r1])/2 + (double)(midmid + 2*d - x[l2])*(h2 + y[l2])/2;
if(ret1 < ret2)
left = mid+eps;
else right = midmid-eps;
}
return ret1;
}
int input()
{
char ch;
ch = getchar();
while(ch < '0' || ch >'9')
{
ch = getchar();
}
int ret = 0;
while(ch >= '0' && ch <= '9')
{
ret *= 10;
ret += ch -'0';
ch = getchar();
}
return ret;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&L);
for(int i = 1;i <= n;i++)
{
scanf("%d%d",&x[i],&y[i]);
}
scanf("%d",&d);
double ans = 0;
r1 = 2;
l2 = 1;
double tmp = 0;
while(l2 < n && x[l2+1] < 2*d)l2++;
for(int i = r1;i < l2;i++)
{
tmp += (double)(x[i+1] - x[i])*(y[i] + y[i+1])/2;
}
if(l2 == 1)
{
tmp -= (double)(x[2] - x[1])*(y[2] + y[1])/2;
}
x[n+1] = x[n];
y[n+1] = y[n];
nowx = 0;
while(l2 < n && r1 <= n)
{
int p1 = x[r1];
int p2 = x[l2 + 1] - 2*d;
if(p1 < p2)
nextx = p1;
else nextx = p2;
nextx = min(L- 2*d,nextx);
ans = max(ans,tmp + solve());
if(p1 < p2)
{
nowx = p1;
if(r1 < n)tmp -= (double)(x[r1+1] - x[r1])*(y[r1+1] + y[r1] )/2;
r1++;
}
else
{
nowx = p2;
tmp += (double)(x[l2+1] - x[l2])*(y[l2+1] + y[l2])/2;
l2++;
}
}
printf("%.3lf\n",ans/2/d);
}
return 0;
}

124
HDOJ/4818_autoAC.cpp Normal file
View File

@ -0,0 +1,124 @@
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <math.h>
using namespace std;
#define eps 1e-6
const int MAXN=220;
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(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;
}
vector<int>vec[MAXN];
int g[MAXN][MAXN];
int du[MAXN];
int add[MAXN];
int main()
{
int T;
int n,m;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
for(int i = 0;i < n;i++)
vec[i].clear();
memset(g,0,sizeof(g));
memset(du,0,sizeof(du));
int u,v;
while(m--)
{
scanf("%d%d",&u,&v);
if(u == v)continue;
g[u][v] = 1;
}
for(int i = 0;i < n;i++)
{
for(int j = 0;j < n;j++)
if(j != i && g[i][j])
{
du[i]++;
vec[j].push_back(i);
}
}
equ = var = n;
for(int i = 0;i < n;i++)
x[i] = 0;
memset(a,0,sizeof(a));
for(int i = 0;i < n;i++)
{
a[i][i] = -1;
int sz = vec[i].size();
for(int j = 0;j < sz;j++)
{
int v = vec[i][j];
if(i == v)continue;
a[i][v] = 1.0 / du[v];
}
}
for(int i = 0;i < n;i++)
a[n-1][i] = 1;
x[n-1] = 1;
for(int k = 0;k < n-1;k++)
if(g[n-1][k] == 0)
{
for(int i = 0;i < n-1;i++)
{
if(g[n-1][i])a[i][var] = 1.0/(du[n-1]+1);
else a[i][var] = 0;
}
a[k][var] = 1.0/(du[n-1]+1);
a[n-1][var] = 1;
add[var] = k;
var++;
}
if(!Gauss())
{
printf("INF\n");
continue;
}
double tt = x[n-1];
double now = x[n-1];
int ans = -1;
for(int i = n;i < var;i++)
{
if(x[n-1]/a[n-1][i] > now)
{
ans = add[i];
now = x[n-1]/a[n-1][i];
}
}
printf("%d %d\n",1,ans);
}
return 0;
}

150
HDOJ/4819_autoAC.cpp Normal file
View File

@ -0,0 +1,150 @@
#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 INF = 0x3f3f3f3f;
const int MAXN = 1010;
struct Nodey
{
int l,r;
int Max,Min;
};
int locy[MAXN],locx[MAXN];
struct Nodex
{
int l,r;
Nodey sty[MAXN*4];
void build(int i,int _l,int _r)
{
sty[i].l = _l;
sty[i].r = _r;
sty[i].Max = -INF;
sty[i].Min = INF;
if(_l == _r)
{
locy[_l] = i;
return;
}
int mid = (_l + _r)/2;
build(i<<1,_l,mid);
build((i<<1)|1,mid+1,_r);
}
int queryMin(int i,int _l,int _r)
{
if(sty[i].l == _l && sty[i].r == _r)
return sty[i].Min;
int mid = (sty[i].l + sty[i].r)/2;
if(_r <= mid)return queryMin(i<<1,_l,_r);
else if(_l > mid)return queryMin((i<<1)|1,_l,_r);
else return min(queryMin(i<<1,_l,mid),queryMin((i<<1)|1,mid+1,_r));
}
int queryMax(int i,int _l,int _r)
{
if(sty[i].l == _l && sty[i].r == _r)
return sty[i].Max;
int mid = (sty[i].l + sty[i].r)/2;
if(_r <= mid)return queryMax(i<<1,_l,_r);
else if(_l > mid)return queryMax((i<<1)|1,_l,_r);
else return max(queryMax(i<<1,_l,mid),queryMax((i<<1)|1,mid+1,_r));
}
}stx[MAXN*4];
int n;
void build(int i,int l,int r)
{
stx[i].l = l;
stx[i].r = r;
stx[i].build(1,1,n);
if(l == r)
{
locx[l] = i;
return;
}
int mid = (l+r)/2;
build(i<<1,l,mid);
build((i<<1)|1,mid+1,r);
}
void Modify(int x,int y,int val)
{
int tx = locx[x];
int ty = locy[y];
stx[tx].sty[ty].Min = stx[tx].sty[ty].Max = val;
for(int i = tx;i;i >>= 1)
for(int j = ty;j;j >>= 1)
{
if(i == tx && j == ty)continue;
if(j == ty)
{
stx[i].sty[j].Min = min(stx[i<<1].sty[j].Min,stx[(i<<1)|1].sty[j].Min);
stx[i].sty[j].Max = max(stx[i<<1].sty[j].Max,stx[(i<<1)|1].sty[j].Max);
}
else
{
stx[i].sty[j].Min = min(stx[i].sty[j<<1].Min,stx[i].sty[(j<<1)|1].Min);
stx[i].sty[j].Max = max(stx[i].sty[j<<1].Max,stx[i].sty[(j<<1)|1].Max);
}
}
}
int queryMin(int i,int x1,int x2,int y1,int y2)
{
if(stx[i].l == x1 && stx[i].r == x2)
return stx[i].queryMin(1,y1,y2);
int mid = (stx[i].l + stx[i].r)/2;
if(x2 <= mid)return queryMin(i<<1,x1,x2,y1,y2);
else if(x1 > mid)return queryMin((i<<1)|1,x1,x2,y1,y2);
else return min(queryMin(i<<1,x1,mid,y1,y2),queryMin((i<<1)|1,mid+1,x2,y1,y2));
}
int queryMax(int i,int x1,int x2,int y1,int y2)
{
if(stx[i].l == x1 && stx[i].r == x2)
return stx[i].queryMax(1,y1,y2);
int mid = (stx[i].l + stx[i].r)/2;
if(x2 <= mid)return queryMax(i<<1,x1,x2,y1,y2);
else if(x1 > mid)return queryMax((i<<1)|1,x1,x2,y1,y2);
else return max(queryMax(i<<1,x1,mid,y1,y2),queryMax((i<<1)|1,mid+1,x2,y1,y2));
}
int main()
{
int T;
scanf("%d",&T);
int iCase = 0;
while(T--)
{
iCase++;
printf("Case #%d:\n",iCase);
scanf("%d",&n);
build(1,1,n);
for(int i = 1;i <= n;i++)
for(int j = 1;j <= n;j++)
{
int a;
scanf("%d",&a);
Modify(i,j,a);
}
int q;
int x,y,L;
scanf("%d",&q);
while(q--)
{
scanf("%d%d%d",&x,&y,&L);
int x1 = max(x - L/2,1);
int x2 = min(x + L/2,n);
int y1 = max(y - L/2,1);
int y2 = min(y + L/2,n);
int Max = queryMax(1,x1,x2,y1,y2);
int Min = queryMin(1,x1,x2,y1,y2);
int t = (Max+Min)/2;
printf("%d\n",t);
Modify(x,y,t);
}
}
return 0;
}

89
HDOJ/4821_autoAC.cpp Normal file
View File

@ -0,0 +1,89 @@
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <math.h>
using namespace std;
int HASH;
const int MAXN = 100010;
int now ;
struct HASHMAP
{
int head[10007],next[MAXN],size;
unsigned long long state[MAXN];
int f[MAXN];
void init()
{
size = 0;
for(int i = 0;i < HASH ;i++)
head[i] = -1;
}
int insert(unsigned long long val,int _id)
{
int h = val % HASH;
for(int i = head[h];i != -1;i = next[i])
{
if(val == state[i])
{
int tmp = f[i];
f[i] = _id;
return tmp;
}
}
f[size] = _id;
state[size] = val;
next[size] = head[h];
head[h] = size++;
return 0;
}
}H;
const int SEED = 13331;
unsigned long long P[MAXN];
unsigned long long S[MAXN];
unsigned long long a[MAXN];
char str[MAXN];
int main()
{
P[0] = 1;
for(int i = 1;i < MAXN;i++)
P[i] = P[i-1]*SEED;
int M,L;
now = -1;
while(scanf("%d%d",&M,&L) == 2)
{
now --;
scanf("%s",str);
int n = strlen(str);
S[0] = 0;
for(int i = 1;i <= n;i++)
S[i] = S[i-1]*SEED + str[i-1];
int ans = 0;
if(L>= 300)
HASH = 10007;
else
HASH = 107;
for(int st = 1;st <= L;st++)
{
H.init();
int tmp = 1;
int cnt = 0;
for(int i = st; i + L - 1 <= n;i += L)
a[++cnt] = S[i+L - 1] - S[i-1] * P[L];
for(int i = 1;i <= cnt;i++)
{
int l = H.insert(a[i],i);
if(i - l >= M)continue;
ans += max(0, i - M - tmp + 1);
tmp = max(tmp,l + 1);
}
ans += max(0,cnt+1 - M - tmp+1);
}
printf("%d\n",ans);
}
return 0;
}

148
HDOJ/4822_autoAC.cpp Normal file
View File

@ -0,0 +1,148 @@
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <iomanip>
#include <cassert>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
#define ff(i, n) for(int i=0;i<(n);i++)
#define fff(i, n, m) for(int i=(n);i<=(m);i++)
#define dff(i, n, m) for(int i=(n);i>=(m);i--)
#define bit(n) (1LL<<(n))
typedef long long LL;
typedef unsigned long long ULL;
void work();
int main()
{
work();
}
void nextInt(int & x)
{
char ch;
while(ch = getchar(), isdigit(ch) == false);
x = 0;
while(x = 10 * x + ch - '0', ch = getchar(), isdigit(ch) == true);
}
const int maxv = 100010;
const int maxe = 200020;
const int maxlog = 20;
int n, m;
int first[maxv], ecnt;
int vv[maxe], nxt[maxe];
void init()
{
memset(first, 0, sizeof(first));
ecnt = 2;
}
void addEdge(int u, int v)
{
nxt[ecnt] = first[u], vv[ecnt] = v, first[u] = ecnt ++;
}
int fa[maxlog][maxv];
int dep[maxv], size[maxv];
void dfs(int u, int f, int d)
{
fa[0][u] = f, size[u] = 1, dep[u] = d;
for(int e = first[u]; e; e = nxt[e]) if(vv[e] != f)
{
dfs(vv[e], u, d + 1);
size[u] += size[vv[e]];
}
}
void initFa()
{
dfs(1, -1, 0);
ff(k, maxlog-1) fff(u, 1, n) if(fa[k][u] == -1)
fa[k+1][u] = -1;
else
fa[k+1][u] = fa[k][fa[k][u]];
}
int upSlope(int u, int p)
{
assert(p <= dep[u]);
ff(k, maxlog) if(p & bit(k))
u = fa[k][u];
return u;
}
int lca(int u, int v)
{
if (dep[u] < dep[v]) swap(u, v);
u = upSlope(u, dep[u] - dep[v]);
if (u == v) return u;
dff(k, maxlog-1, 0) if (fa[k][u] != fa[k][v])
u = fa[k][u], v = fa[k][v];
return fa[0][u];
}
struct Node
{
int type, r;
Node(int type, int r) : type(type), r(r) {}
};
Node getMiddle(int a, int b, int ab)
{
int d = dep[a] + dep[b] - 2 * dep[ab];
if (dep[a] >= dep[b])
return Node(1, upSlope(a, (d - 1)/2));
else
return Node(2, upSlope(b, d/2));
}
int calc(int a, int b, int c, int ab, int ac)
{
Node bn = getMiddle(a, b, ab);
Node cn = getMiddle(a, c, ac);
if (bn.type + cn.type == 2)
{
return min(size[bn.r], size[cn.r]);
}
else if (bn.type + cn.type == 4)
{
if(dep[bn.r] > dep[cn.r]) swap(bn, cn);
if (lca(bn.r, cn.r) == bn.r)
return n - size[bn.r];
else
return n - size[bn.r] - size[cn.r];
}
else
{
if (bn.type == 2) swap(bn, cn);
if (lca(bn.r, cn.r) == bn.r)
return size[bn.r] - size[cn.r];
else
return size[bn.r];
}
}
void work()
{
int T;
scanf("%d", &T);
fff(cas, 1, T)
{
init();
scanf("%d", &n);
ff(i, n-1)
{
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
initFa();
scanf("%d", &m);
while(m--)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int ab = lca(a, b);
int ac = lca(a, c);
int bc = lca(b, c);
printf("%d %d %d\n", calc(a, b, c, ab, ac), calc(b, a, c, ab, bc), calc(c, a, b, ac, bc));
}
}
}

39
HDOJ/4823_autoAC.cpp Normal file
View File

@ -0,0 +1,39 @@
#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
long long n,m,v,k;
cin>>n>>m>>v>>k;
if(m>=n)
{
cout<<0<<endl;
}
else
{
int co=0;
while(m<n)
{
if((m-v)*k>m)
{
m=(m-v)*k;
co++;
}
else
{
co=-1;
break;
}
}
cout<<co<<endl;
}
}
return 0;
}

57
HDOJ/4824_autoAC.cpp Normal file
View File

@ -0,0 +1,57 @@
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define max3(a,b,c) (max(a,max(b,c)))
#define min(a,b) ((a)<(b)?(a):(b))
const int N=1005;
struct Point
{
int road,area;
void Get ()
{
scanf("%d%d",&road,&area);
}
int Dis (Point b)
{
int tmp=fabs(b.area-area);
return 400*fabs(b.road-road)+min( tmp,360-tmp);
}
}data[N];
int dis[N][N];
int dp[N][N];
int main ()
{
int T,i,j,n;
scanf("%d",&T);
while (T--)
{
scanf("%d",&n);
data[0].area=0;
data[0].road=0;
memset(dis,0,sizeof(dis));
memset(dp,0,sizeof(dp));
for (i=1;i<=n;i++)
data[i].Get();
for (i=0;i<=n;i++)
for (j=i+1;j<=n;j++)
dis[i][j]=dis[j][i]=data[i].Dis(data[j]);
dp[0][0]=0;
n++;
for (i=1;i<n;i++)
dp[i][0]=dis[i][0];
for (i=1;i<n-1;i++)
{
dp[i+1][i]=1000000000;
for (j=0;j<=i-1;j++)
{
dp[i+1][j]=dp[i][j]+dis[i][i+1];
dp[i+1][i]=min(dp[i+1][i],dp[i][j]+dis[j][i+1]);
}
}
printf("%d\n",dp[n-1][n-2]+dis[n-1][n-2]+10*(n-1));
}
return 0;
}

104
HDOJ/4825_autoAC.cpp Normal file
View File

@ -0,0 +1,104 @@
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#define LL __int64
using namespace std;
struct Node {
int num;
Node *next[2];
Node() {
num = 0;
for(int i=0; i<2; i++) {
next[i] = NULL;
}
}
};
char ans[123];
int n,m;
void tstrrev(char s[]) {
int l=strlen(s);
for(int i=0,j=l-1; i<l; i++,j--) {
if(i<j) {
s[i]^=s[j];
s[j]^=s[i];
s[i]^=s[j];
}
}
}
void insert(Node *root,char *s) {
Node *p;
p = root;
for(int i=0; s[i]; i++) {
int x = s[i] - '0';
if(p->next[x] == NULL)
p->next[x] = new Node;
p = p->next[x];
p->num ++;
}
}
void search(Node *root,char *s) {
memset(ans,0,sizeof(ans));
Node *p;
p = root;
for(int i=0; i<32; i++) {
int x = s[i] - '0';
if(p->next[x] != NULL) {
p = p->next[x];
ans[i] = s[i];
} else {
if(x == 1) x = 0;
else x = 1;
p = p->next[x];
ans[i] = x + '0';
}
}
}
int main() {
int _;
scanf("%d",&_);
for(int cas=1; cas<=_; cas++) {
scanf("%d%d",&n,&m);
LL tmp;
Node *root = new Node;
while(n--) {
scanf("%I64d",&tmp);
char str[40];
for(int i=0; i<32; i++) {
str[i] = tmp % 2 + '0';
tmp /= 2;
}
str[32] = '\0';
tstrrev(str);
insert(root,str);
}
printf("Case #%d:\n",cas);
while(m--) {
scanf("%I64d",&tmp);
char str[40];
for(int i=0; i<32; i++) {
str[i] = tmp % 2 + '0';
tmp /= 2;
}
str[32] = '\0';
tstrrev(str);
for(int i=0; i<32; i++) {
if(str[i] == '1') {
str[i] = '0';
} else {
str[i] = '1';
}
}
search(root,str);
tstrrev(ans);
LL hehe = 0;
LL mul = 1;
for(int i=0; i<32; i++) {
hehe += mul * (ans[i] - '0');
mul *= 2;
}
printf("%I64d\n",hehe);
}
}
return 0;
}

49
HDOJ/4826_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int ans[105][105];
int dpu[105];
int dpd[105];
int main()
{
int t;
cin>>t;
int cas=0;
while(t--)
{
int m,n;
cin>>m>>n;
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
cin>>ans[i][j];
}
}
for(int i=2;i<=m;i++)
{
ans[i][1]+=ans[i-1][1];
}
for(int j=2;j<=n;j++)
{
dpu[0]=dpu[m+1]=dpd[0]=dpd[m+1]=-9999999;
for(int i=m;i>=1;i--)
{
dpu[i]=max(dpu[i+1],ans[i][j-1])+ans[i][j];
}
for(int i=1;i<=m;i++)
{
dpd[i]=max(dpd[i-1],ans[i][j-1])+ans[i][j];
}
for(int i=1;i<=m;i++)
{
ans[i][j]=max(dpu[i],dpd[i]);
}
}
printf("Case #%d:\n%d\n",++cas,ans[1][n]);
}
return 0;
}

31
HDOJ/4828_autoAC.cpp Normal file
View File

@ -0,0 +1,31 @@
#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;
long long C[1000005] = {0LL};
long long spow(long long x, int n)
{
if (n == 1)
return x;
else {
long long v = spow(x, n/2);
if (n%2 == 0) return v*v%1000000007LL;
else return v*v%1000000007LL*x%1000000007LL;
}
}
int main()
{
C[1] = 1LL;
for (int i = 2 ; i < 1000001 ; ++ i) {
C[i] = C[i-1]*(4*i-2)%1000000007LL;
C[i] = C[i]*spow(i+1, 1000000005)%1000000007LL;
}
int n,m;
while (cin >> n)
for (int i = 1 ; i <= n ; ++ i) {
cin >> m;
cout << "Case #" << i << ":" << endl;
cout << C[m] << endl;
}
return 0;
}

107
HDOJ/4829_autoAC.cpp Normal file
View File

@ -0,0 +1,107 @@
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <ctime>
using namespace std;
#define LL long long
#define ULL unsigned long long
#define REP(i,a,b) for(int i=a;i<=b;++i)
#define maxn 1111111
#define mset(a) memset(a,0,sizeof a)
const LL MOD=9999991;
int father[maxn];
int x[maxn],y[maxn];
int v[maxn];
int ve;
int findfather(int xx)
{
if(father[xx]==xx)
return xx;
int fa=findfather(father[xx]);
x[xx]+=x[father[xx]];
y[xx]+=y[father[xx]];
father[xx]=fa;
return fa;
}
void unit(int aa,int bb,int X,int Y)
{
int fa=findfather(aa);
int fb=findfather(bb);
if(fa!=fb)
{
father[fa]=fb;
x[fa]=x[bb]+X-x[aa];
y[fa]=y[bb]+Y-y[aa];
}
else
{
int bax=x[aa]-x[bb];
int bay=y[aa]-y[bb];
if(bax!=X||bay!=Y)
puts("REJECT");
}
}
bool sf(int a,int b)
{
int fa=findfather(a);
int fb=findfather(b);
return fa==fb;
}
void newv(int a)
{
v[a]=++ve;
father[ve]=ve;
x[ve]=0;
y[ve]=0;
}
int main()
{
int t;
cin>>t;
int n;
REP(c,1,t)
{
ve=0;
x[0]=y[0]=v[0]=father[0]=0;
printf("Case #%d:\n",c);
scanf("%d",&n);
REP(i,0,n)
{newv(i);father[i]=i;v[i]=i;}
mset(x);
mset(y);
int q,a,b,xx,yy;
REP(i,1,n)
{
scanf("%d",&q);
if(q==1||q==2)
{
b=0;
if(q==1) scanf("%d%d%d%d",&a,&b,&xx,&yy);
else scanf("%d%d%d",&a,&xx,&yy);
newv(a);
unit(v[a],v[b],xx,yy);
}
if(q==3||q==4)
{
b=0;
if(q==3) scanf("%d%d%d%d",&a,&b,&xx,&yy);
else scanf("%d%d%d",&a,&xx,&yy);
unit(v[a],v[b],xx,yy);
}
if(q==5||q==6)
{
b=0;
if(q==5)
scanf("%d%d",&a,&b);
else scanf("%d",&a);
a=v[a];
b=v[b];
if(!sf(a,b))
puts("UNKNOWN");
else printf("%d %d\n",x[a]-x[b],y[a]-y[b]);
}
}
}
}

156
HDOJ/4831_autoAC.cpp Normal file
View File

@ -0,0 +1,156 @@
#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 = 100010;
long long c[MAXN];
int lowbit(int x)
{
return x&(-x);
}
long long sum(int i)
{
long long ret = 0;
while(i > 0)
{
ret += c[i];
i -= lowbit(i);
}
return ret;
}
void add(int i,long long val)
{
while(i <= 100000)
{
c[i] += val;
i += lowbit(i);
}
}
int s1[MAXN];
int s2[MAXN];
int sz1,sz2;
vector<int>vec1[10010];
vector<int>vec2[10010];
int a[10010];
int b[10010];
void calc(int u)
{
int id = lower_bound(s1,s1+sz1,s2[u]) - s1;
if(id == 0)
{
vec1[0].push_back(u);
vec2[u].push_back(0);
}
else if(id == sz1)
{
vec1[sz1-1].push_back(u);
vec2[u].push_back(sz1-1);
}
else
{
if(s2[u] - s1[id-1] < s1[id] - s2[u] )
{
vec1[id-1].push_back(u);
vec2[u].push_back(id-1);
}
else if(s2[u] - s1[id-1] > s1[id] - s2[u])
{
vec1[id].push_back(u);
vec2[u].push_back(id);
}
else
{
vec1[id-1].push_back(u);
vec2[u].push_back(id-1);
vec1[id].push_back(u);
vec2[u].push_back(id);
}
}
}
int get(int u)
{
if(vec2[u].size() == 1)
{
return a[vec2[u][0]];
}
else
{
return max(a[vec2[u][0]],a[vec2[u][1]]);
}
}
int link[10010];
int main()
{
int T;
int iCase = 0;
int n;
scanf("%d",&T);
while(T--)
{
iCase++;
printf("Case #%d:\n",iCase);
sz1 = 0;sz2 = 0;
memset(c,0,sizeof(c));
int u,v;
scanf("%d",&n);
for(int i = 0;i < n;i++)
{
scanf("%d%d",&u,&v);
if(v == 0)
s2[sz2++] = u;
else
{
s1[sz1++] = u;
link[i] = sz1-1;
add(v,1);
a[sz1-1] = v;
}
vec1[i].clear();
vec2[i].clear();
}
for(int i = 0;i < sz2;i++)
calc(i);
for(int i = 0;i < sz2;i++)
{
b[i] = get(i);
add(b[i],1);
}
char op[10];
int m;
scanf("%d",&m);
while(m--)
{
scanf("%s",op);
if(op[0] == 'Q')
{
scanf("%d",&u);
printf("%d\n",(int)sum(u));
}
else
{
scanf("%d%d",&u,&v);
u = link[u];
add(a[u],-1);
a[u] = v;
add(a[u],1);
for(int i = 0;i < vec1[u].size();i++)
{
int p = get(vec1[u][i]);
add(b[vec1[u][i]],-1);
b[vec1[u][i]] = p;
add(p,1);
}
}
}
}
return 0;
}

116
HDOJ/4832_autoAC.cpp Normal file
View File

@ -0,0 +1,116 @@
#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 MOD = 9999991;
int C[1010][1010];
int dp1[2020][1010];
int dp2[2020][1010];
int x,y;
int n,m;
int k;
void add(int &a,int b)
{
a += b;
if(a >= MOD)a -= MOD;
}
int sum1[1010];
int sum2[1010];
void init()
{
C[0][0] = 1;
for(int i = 1;i < 1010;i++)
{
C[i][0] = C[i][i] = 1;
for(int j = 1; j < i;j++)
{
C[i][j] = C[i-1][j] + C[i-1][j-1];
if(C[i][j] >= MOD)
C[i][j] -= MOD;
}
}
memset(dp1,0,sizeof(dp1));
memset(dp2,0,sizeof(dp2));
dp1[y][0] = 1;
for(int t = 1;t <= k;t++)
for(int i = 1;i <= m;i++)
{
dp1[i][t] = 0;
if(i-2 >= 1)
{
add(dp1[i][t],dp1[i-2][t-1]);
}
if(i - 1 >= 1)
{
add(dp1[i][t],dp1[i-1][t-1]);
}
if(i + 1 <= m)
{
add(dp1[i][t],dp1[i+1][t-1]);
}
if(i+2 <= m)
{
add(dp1[i][t],dp1[i+2][t-1]);
}
}
dp2[x][0] = 1;
for(int t = 1;t <= k;t++)
for(int i = 1;i <= n;i++)
{
dp2[i][t] = 0;
if(i-2 >= 1)
{
add(dp2[i][t],dp2[i-2][t-1]);
}
if(i - 1 >= 1)
{
add(dp2[i][t],dp2[i-1][t-1]);
}
if(i + 1 <= n)
{
add(dp2[i][t],dp2[i+1][t-1]);
}
if(i+2 <= n)
{
add(dp2[i][t],dp2[i+2][t-1]);
}
}
memset(sum1,0,sizeof(sum1));
for(int i = 0;i <= k;i++)
for(int j = 1;j <= m;j++)
add(sum1[i],dp1[j][i]);
memset(sum2,0,sizeof(sum2));
for(int i = 0;i <= k;i++)
for(int j = 1;j <= n;j++)
add(sum2[i],dp2[j][i]);
}
int main()
{
int T;
int iCase = 0;
scanf("%d",&T);
while(T--)
{
iCase++;
printf("Case #%d:\n",iCase);
scanf("%d%d%d%d%d",&n,&m,&k,&x,&y);
init();
long long ans = 0;
for(int i = 0;i <= k;i++)
{
ans += (long long)C[k][i] * sum1[i]%MOD*sum2[k-i]%MOD;
ans %= MOD;
}
printf("%d\n",(int)ans);
}
return 0;
}

100
HDOJ/4833_autoAC.cpp Normal file
View File

@ -0,0 +1,100 @@
#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 NN1
{
int d,e;
void input()
{
scanf("%d%d",&d,&e);
}
}node1[3000];
struct NN2
{
int start,finish;
int r;
void input()
{
scanf("%d%d%d",&start,&finish,&r);
}
}node2[3000];
int a[5010];
long long f[100010];
long long f2[5010];
int dp[5010];
vector<int>vec[5010];
vector<int>vec2[5010];
int main()
{
int T;
int iCase = 0;
int n,m;
scanf("%d",&T);
while(T--)
{
iCase++;
printf("Case #%d:\n",iCase);
scanf("%d%d",&n,&m);
int cnt = 0;
memset(f,0,sizeof(f));
for(int i = 0;i < n;i++)
{
node1[i].input();
f[node1[i].d] += node1[i].e;
}
for(int i = 1;i <= 100000;i++)
f[i] += f[i-1];
for(int i = 0;i < m;i++)
{
node2[i].input();
a[cnt++] = node2[i].start;
a[cnt++] = node2[i].finish;
}
sort(a,a+cnt);
cnt = unique(a,a+cnt) - a;
map<int,int>mp;
for(int i = 0;i < cnt;i++)
mp[a[i]] = i;
f2[0] = f[a[0]];
for(int i = 1;i < cnt;i++)
f2[i] = f[a[i]] - f[a[i-1]];
for(int i = 0;i < cnt;i++)
{
vec[i].clear();
vec2[i].clear();
}
for(int i = 0;i < m;i++)
{
node2[i].start = mp[node2[i].start];
node2[i].finish = mp[node2[i].finish];
vec[node2[i].start].push_back(node2[i].finish);
vec2[node2[i].start].push_back(node2[i].r);
}
memset(dp,0,sizeof(dp));
for(int i = cnt-1;i >= 0;i--)
{
dp[i] = dp[i+1];
int sz = vec[i].size();
for(int j = 0;j < sz;j++)
dp[i] = max(dp[i],dp[vec[i][j]] + vec2[i][j]);
}
long long ans ;
ans = 0;
for(int i = 0;i < cnt;i++)
{
ans += (long long)dp[i]*f2[i];
}
printf("%.2lf\n",(double)ans/100);
}
return 0;
}

49
HDOJ/4834_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
using namespace std;
const int MAXN=10000010;
bool nprime[MAXN];
int prime[750000],tot,dnum[MAXN],tms[MAXN],tms2[MAXN];
int s1[MAXN];
long long s2[MAXN];
int n,m;
long long ans;
void getPrime(int n)
{
for(int i=2;i<=n;i++)
{
if(!nprime[i]) {prime[++tot]=i,dnum[i]=2,tms[i]=1;}
for(int j=1;(j<=tot)&&(i*prime[j]<=n);j++)
{
nprime[i*prime[j]]=true;
if(i%prime[j]==0)
{
dnum[i*prime[j]]=dnum[i]/(tms[i]+1)*(tms[i]+2);
tms[i*prime[j]]=tms[i]+1;
break;
}
dnum[i*prime[j]]=dnum[i]*dnum[prime[j]];
tms[i*prime[j]]=1;
}
}
}
int main()
{
getPrime(10000000);
tms2[1]=0,tms2[2]=1,dnum[1]=1;
for(int i=3;i<=10000000;i++) if(!(i&1)) tms2[i]=tms2[i>>1]+1;
for(int i=1;i<=10000000;i++)
dnum[i]/=tms2[i]+1,s1[i]=s1[i-1]+(long long)dnum[i],s2[i]=s2[i-1]+(long long)i*dnum[i];
scanf("%d",&m);
for(int cas=1;cas<=m;cas++)
{
scanf("%d",&n);
ans=n+1+(long long)s1[n-1]*n-s2[n-1];
printf("Case #%d:\n",cas);
printf("%I64d\n",ans);
}
return 0;
}

132
HDOJ/4836_autoAC.cpp Normal file
View File

@ -0,0 +1,132 @@
#include <stdio.h>
#include <vector>
#include <string>
#include <queue>
#include <string.h>
#include <algorithm>
using namespace std;
#define repe(i,now) for(int i=head[now];i!=-1;i=edge[i].next)
#define rep(i,s,t) for(int i=s;i<t;i++)
#define clr(a,v) memset(a,v,sizeof a)
#define L t<<1
#define R t<<1|1
#define lowbit(x) (x&(-x))
const int N=10005;
struct Edge{
int v,next;
}edge[N*2];
int head[N],e;
int t,n,a,b,v[N],to[N],rTo[N],last[N],fa[N][20],dep[N],cnt,q,x,y,all,r;
char op[10];
int c[N];
inline void add(int x,int v){
while(x<=n){
c[x]+=v;x+=lowbit(x);
}
}
inline int sum(int x){
int a=0;
while(x>0){
a+=c[x];x-=lowbit(x);
}
return a;
}
inline void addEdge(int u,int v){
edge[e].v=v;
edge[e].next=head[u];
head[u]=e++;
}
inline void dfs(int now,int pre){
to[now]=(++cnt);rTo[cnt]=now;
fa[now][0]=pre;
dep[now]=dep[pre]+1;
rep(i,1,20) fa[now][i]=fa[fa[now][i-1]][i-1];
repe(i,now){
int nxt=edge[i].v;
if(nxt!=pre){
dfs(nxt,now);
}
}
last[now]=cnt;
}
inline int lca(int a,int b){
if(dep[a]>dep[b]) swap(a,b);
int ha=dep[a],hb=dep[b];
int ta=a,tb=b;
int det=hb-ha;
rep(i,0,20){
if(det&(1<<i)){
tb=fa[tb][i];
}
}
if(ta==tb) return ta;
for(int i=19;i>=0;i--){
if(fa[ta][i]==fa[tb][i]) continue;
ta=fa[ta][i];
tb=fa[tb][i];
}
return fa[ta][0];
}
inline void Init(){
scanf("%d",&n);
clr(head,-1),e=all=cnt=0;
r=1;
rep(i,1,n){
scanf("%d%d",&a,&b);
addEdge(a,b);
addEdge(b,a);
}
rep(i,1,n+1) scanf("%d",&v[i]),all+=v[i];
fa[1][0]=1;
dep[0]=0;
dfs(1,0);
}
inline int find(int x,int y){
int det=dep[y]-dep[x]-1;
rep(i,0,20){
if(det&(1<<i)){
y=fa[y][i];
}
}
return y;
}
inline void Work(){
clr(c,0);
rep(i,1,n+1) add(to[i],v[i]);
scanf("%d",&q);
rep(i,0,q){
scanf("%s",op);
if(op[0]=='Q'){
scanf("%d",&x);
a=lca(x,r);
if(x==r){
printf("%d\n",all);
}
else if(a!=x){
printf("%d\n",sum(last[x])-sum(to[x]-1));
}
else{
b=find(x,r);
printf("%d\n",all-sum(last[b])+sum(to[b]-1));
}
}
else if(op[0]=='R'){
scanf("%d",&x);r=x;
}
else{
scanf("%d%d",&x,&y);
add(to[x],y-v[x]);
all+=y-v[x];
v[x]=y;
}
}
}
int main(){
scanf("%d",&t);
rep(ca,1,t+1){
printf("Case #%d:\n",ca);
Init();
Work();
}
return 0;
}

26
HDOJ/4841_autoAC.cpp Normal file
View File

@ -0,0 +1,26 @@
#include <stdio.h>
#include <string.h>
#define maxn 32800
bool arr[maxn << 1];
int main() {
int n, m, i, j, cnt, cas = 0;
while(scanf("%d%d", &n, &m) == 2) {
memset(arr, 0, sizeof(bool) * n * 2);
for(i = j = 0; i < n; ++i) {
cnt = 0;
while(true) {
if(arr[j] == false) {
if(++cnt == m) break;
}
if(++j == 2 * n) j = 0;
}
arr[j] = true;
}
for(i = 0; i < n * 2; ++i) {
putchar(arr[i] ? 'B' : 'G');
if((i + 1) % 50 == 0) putchar('\n');
}
putchar('\n'); putchar('\n');
}
return 0;
}

77
HDOJ/4845_autoAC.cpp Normal file
View File

@ -0,0 +1,77 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
#define MAXN 20
#define MAXKEY 11
int door[MAXN][MAXN][MAXN][MAXN];
int keys[MAXN][MAXN];
int n, m, p;
struct NODE{
int x, y;
int step;
int havkey;
};
int dir[4][2] = {0,1, 0,-1, 1,0, -1,0};
bool vis[MAXN][MAXN][1<<11];
int bfs()
{
queue<NODE> Q;
NODE st;
st.x = st.y = 1;
st.step = 0;
st.havkey = keys[1][1];
Q.push(st);
while(!Q.empty()){
NODE cur = Q.front();
Q.pop();
if(cur.x == n && cur.y == m) return cur.step;
for(int i=0; i<4; i++){
int tx = cur.x + dir[i][0];
int ty = cur.y + dir[i][1];
if(tx >= 1 && tx <= n && ty >= 1 && ty <= m){
int usekey = door[cur.x][cur.y][tx][ty];
if(usekey == 0) continue;
if(usekey == -1 || ((cur.havkey >> usekey) & 1)){
NODE nod;
nod.x = tx;
nod.y = ty;
nod.step = cur.step+1;
nod.havkey = cur.havkey | keys[tx][ty];
if(vis[nod.x][nod.y][nod.havkey] == false){
vis[nod.x][nod.y][nod.havkey] = true;
Q.push(nod);
}
}
}
}
}
return -1;
}
int main()
{
int k, s;
while(scanf("%d%d%d", &n, &m, &p) != EOF){
memset(door, -1, sizeof door);
memset(keys, 0, sizeof keys);
memset(vis, false, sizeof vis);
scanf("%d", &k);
int x1, x2, y1, y2, g, q;
for(int i=0; i<k; i++){
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &g);
door[x1][y1][x2][y2] = door[x2][y2][x1][y1] = g;
}
scanf("%d", &s);
for(int i=0; i<s; i++){
scanf("%d%d%d", &x1, &y1, &q);
keys[x1][y1] |= (1 << q);
}
int ans = bfs();
printf("%d\n", ans);
}
return 0;
}

43
HDOJ/4846_autoAC.cpp Normal file
View File

@ -0,0 +1,43 @@
#include<cstdio>
#include<cstring>
using namespace std;
int tree[1010][1010];
int sum[1010][1010];
int main()
{ int i,j,k,n,m,x,y,ans,l,r,p,l2,r2,res;
while(~scanf("%d%d",&n,&m))
{ memset(tree,0,sizeof(tree));
for(i=1;i<=m;i++)
{ scanf("%d%d",&x,&y);
tree[x][y]=1;
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
sum[i][j]=sum[i][j-1]+tree[i][j];
ans=0;
l2=1;r2=n;
while(l2<r2)
{ i=(l2+r2+1)/2;
res=0;ans=0;
for(j=1;j<=n-i+1;j++)
{ l=j;r=j+i-1;p=0;
for(k=1;k<=n;k++)
{ if(sum[k][r]-sum[k][l-1]>0)
p=0;
else
{ p++;
if(p>=i)
{ ans=i;
break;
}
}
}
}
if(ans>0)
l2=i;
else
r2=i-1;
}
printf("%d\n",l2);
}
}

17
HDOJ/4847_autoAC.cpp Normal file
View File

@ -0,0 +1,17 @@
#include <stdio.h>
#include <string.h>
char c;
char a[5];
int main() {
a[5] = '\0';
int ans = 0;
while ((c = getchar()) != EOF) {
if (c >= 'a' && c <= 'z') c -= 32;
a[3] = c;
if (strcmp(a, "DOGE") == 0) ans++;
for (int i = 0; i < 3; i++)
a[i] = a[i + 1];
}
printf("%d\n", ans);
return 0;
}

56
HDOJ/4848_autoAC.cpp Normal file
View File

@ -0,0 +1,56 @@
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std ;
const int INF=0xfffffff ;
int n ;
int dis[55][55],ti[55],vis[55],ans ;
void floyd()
{
for(int k=0 ;k<n ;k++)
{
for(int i=0 ;i<n ;i++)
{
for(int j=0 ;j<n ;j++)
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]) ;
}
}
}
void dfs(int now,int s,int t,int sum)
{
if(s==n)
{
ans=min(ans,sum) ;
return ;
}
if(sum>ans)return ;
for(int i=1 ;i<n ;i++)
if(!vis[i] && dis[now][i]+t>ti[i])return ;
for(int i=1 ;i<n ;i++)
{
if(!vis[i])
{
vis[i]=1 ;
dfs(i,s+1,t+dis[now][i],sum+dis[now][i]*(n-s)) ;
vis[i]=0 ;
}
}
}
int main()
{
while(~scanf("%d",&n))
{
for(int i=0 ;i<n ;i++)
for(int j=0 ;j<n ;j++)
scanf("%d",&dis[i][j]) ;
for(int i=1 ;i<n ;i++)
scanf("%d",&ti[i]) ;
floyd() ;
ans=INF ;
memset(vis,0,sizeof(vis)) ;
dfs(0,1,0,0) ;
if(ans==INF)puts("-1") ;
else printf("%d\n",ans) ;
}
return 0 ;
}

56
HDOJ/4849_autoAC.cpp Normal file
View File

@ -0,0 +1,56 @@
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
long long INF = 0x7fffffff;
using namespace std;
const int maxn=1000+10;
long long n,m;
long long x[maxn*maxn],y[maxn*maxn],z[maxn*maxn];
long long cost[maxn][maxn];
void init()
{
z[0]= (x[0] * 90123 + y[0] )%8475871 + 1;
z[1]= (x[1] * 90123 + y[1] )%8475871 + 1;
for(int i=2;i<n*n;i++)
{
x[i] = ( (12345)+(x[i-1]*23456)%5837501+(x[i-2]*34567)%5837501+ ((x[i-1]*x[i-2])%5837501)*45678 )%5837501;
y[i] = ( (56789)+(y[i-1]*67890)%9860381+(y[i-2]*78901)%9860381+ ((y[i-1]*y[i-2])%9860381)*89012 )%9860381;
z[i] = (x[i] * 90123 + y[i] )%8475871 + 1;
}
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
if(i==j) cost[i][j]=0;
else cost[i][j] = z[i*n+j];
}
}
bool done[maxn];
long long d[maxn];
void dijkstra()
{
memset(done,0,sizeof(done));
for(int i=0;i<n;i++) d[i]= INF;
d[0]=0;
for(int i=0;i<n;i++)
{
long long x,m=INF;
for(int y=0;y<n;y++)if(!done[y]&&d[y]<=m) m=d[x=y];
done[x]=true;
for(int y=0;y<n;y++)d[y] = min(d[y],d[x]+cost[x][y]);
}
}
int main()
{
while(scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&n,&m,&x[0],&x[1],&y[0],&y[1])==6)
{
init();
dijkstra();
long long ans=INF;
for(int i=1;i<n;i++)
ans = min(ans,d[i]%m);
printf("%I64d\n",ans);
}
return 0;
}

39
HDOJ/4850_autoAC.cpp Normal file
View File

@ -0,0 +1,39 @@
#include <cstdio>
#include <cstring>
const int N = 20005;
int vis[N], vis2[N][30], on = 0;
char out[500005];
int getnext(int x, int a) {
return x % (26 * 26) * 26 + a;
}
void init() {
int now = 0;
for (int i = 0; i < 3; i++)
out[on++] = 'a';
while (true) {
int Min = 26, iv = 0;
for (int i = 1; i < 26; i++) {
if (vis2[now][i]) continue;
int tmp = getnext(now, i);
if (vis[tmp] < Min) {
Min = vis[tmp];
iv = i;
}
}
int tmp = getnext(now, iv);
if (vis[tmp] == 26) break;
vis2[now][iv] = 1;
now = tmp;
vis[now]++;
out[on++] = now % 26 + 'a';
}
}
int n;
int main() {
init();
while (~scanf("%d", &n)) {
if (n > 456979) printf("Impossible\n");
else printf("%s\n", (out + 456979 - n));
}
return 0;
}

109
HDOJ/4856_autoAC.cpp Normal file
View File

@ -0,0 +1,109 @@
#include <iostream>
#include <map>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std ;
const int INF=0xfffffff ;
int n,m ;
char M[25][25] ;
int vis[25][25] ;
int dis[25][25] ;
int dx[]={1,-1,0,0} ;
int dy[]={0,0,1,-1} ;
int dp[16][1<<16] ;
struct node
{
int x1,y1,x2,y2 ;
}kk[25] ;
struct point
{
int x,y,step ;
} ;
int bfs(node a,node b)
{
memset(vis,0,sizeof(vis)) ;
queue <point> q ;
point s ;
s.x=a.x2 ;s.y=a.y2 ;s.step=0 ;
vis[s.x][s.y]=1 ;
q.push(s) ;
while(!q.empty())
{
point u=q.front() ;
q.pop() ;
if(u.x==b.x1 && u.y==b.y1)
{
return u.step ;
}
for(int i=0 ;i<4 ;i++)
{
int xx=u.x+dx[i] ;
int yy=u.y+dy[i] ;
if(xx<0 || xx>=n || yy<0 || yy>=n)continue ;
if(M[xx][yy]=='#')continue ;
if(vis[xx][yy])continue ;
vis[xx][yy]=1 ;
point next ;
next.x=xx ;next.y=yy ;next.step=u.step+1 ;
q.push(next) ;
}
}
return INF ;
}
void INIT()
{
for(int i=0 ;i<25 ;i++)
for(int j=0 ;j<25 ;j++)
dis[i][j]=INF ;
for(int i=0 ;i<m ;i++)
{
for(int j=0 ;j<m ;j++)
{
if(i==j)
{
dis[i][j]=0 ;
continue ;
}
dis[i][j]=bfs(kk[i],kk[j]) ;
}
}
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i=0 ;i<n ;i++)
scanf("%s",M[i]) ;
for(int i=0 ;i<m ;i++)
{
scanf("%d%d%d%d",&kk[i].x1,&kk[i].y1,&kk[i].x2,&kk[i].y2) ;
kk[i].x1-- ;kk[i].y1-- ;kk[i].x2-- ;kk[i].y2-- ;
}
INIT() ;
for(int i=0 ;i<16 ;i++)
for(int j=0 ;j<(1<<16) ;j++)
dp[i][j]=INF ;
for(int i=0 ;i<m ;i++)dp[i][1<<i]=0 ;
int ans=INF ;
for(int i=0 ;i<(1<<m) ;i++)
{
for(int j=0 ;j<m ;j++)
{
if(i&(1<<j))
{
for(int k=0 ;k<m ;k++)
{
if(dis[k][j]==INF || !(i&(1<<k)))continue ;
dp[j][i]=min(dp[j][i],dp[k][i^(1<<j)]+dis[k][j]) ;
}
}
}
}
for(int i=0 ;i<m ;i++)
ans=min(ans,dp[i][(1<<m)-1]) ;
if(ans==INF)puts("-1") ;
else printf("%d\n",ans) ;
}
return 0 ;
}

82
HDOJ/4857_autoAC.cpp Normal file
View File

@ -0,0 +1,82 @@
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
struct list
{
int u,v,w;
int next;
}edge[110000];
int head[33000];
int nums;
void add(int u,int v,int w)
{
edge[nums].u=u;
edge[nums].v=v;
edge[nums].w=w;
edge[nums].next=head[u];
head[u]=nums++;
}
int du[33000];
void init()
{
memset(head,-1,sizeof(head));
nums=1;
memset(du,0,sizeof(du));
}
priority_queue<int>que;
vector<int>vec;
int n;
void dos()
{
vec.clear();
while(!que.empty())que.pop();
for(int i=1;i<=n;i++)
{
if(du[i]==0)que.push(i);
}
while(!que.empty())
{
int x=que.top();
que.pop();
for(int i=head[x];i!=-1;i=edge[i].next)
{
int y=edge[i].v;
du[y]--;
if(du[y]==0)
{
que.push(y);
}
}
vec.push_back(x);
}
for(int i=n-1;i>=0;i--)
{
if(i!=n-1)printf(" ");
printf("%d",vec[i]);
}
cout<<endl;
}
int main()
{
int T,m,a,b;
scanf("%d",&T);
while(T--)
{
init();
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a,&b);
add(b,a,1);
du[a]++;
}
dos();
}
return 0;
}

53
HDOJ/4858_autoAC.cpp Normal file
View File

@ -0,0 +1,53 @@
#include<stdio.h>
#include<iostream>
#include<math.h>
#include<stdlib.h>
#include<ctype.h>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<string.h>
using namespace std;
int n, m, q;
vector<int> g[100010];
int a[100010], b, c, d;
int main()
{
int t;
scanf("%d",&t);
while (t--)
{
scanf("%d%d",&n,&m);
for (int i = 0; i <= n; i++) g[i].clear();
memset(a, 0, sizeof(a));
while (m--)
{
scanf("%d%d",&b,&c);
g[b].push_back(c);
g[c].push_back(b);
}
scanf("%d",&q);
while (q--)
{
scanf("%d",&b);
if (b == 0)
{
scanf("%d%d", &c, &d);
a[c] += d;
}
else
{
int ans = 0;
scanf("%d",&c);
for (int i = 0; i < g[c].size(); i++)
ans += a[g[c][i]];
printf("%d\n",ans);
}
}
}
return 0;
}

158
HDOJ/4859_autoAC.cpp Normal file
View File

@ -0,0 +1,158 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <map>
using namespace std;
const int inf=0x3f3f3f3f;
int head[3010],num[3010],d[3010],pre[3010],cur[3010];
char mp[110][110];
int n,m,cnt,nv,s,t;
int jx[]={0,0,1,-1};
int jy[]={1,-1,0,0};
struct node
{
int u,v,cap;
int next;
}edge[10000010];
void add(int u, int v, int cap)
{
edge[cnt].v=v;
edge[cnt].cap=cap;
edge[cnt].next=head[u];
head[u]=cnt++;
edge[cnt].v=u;
edge[cnt].cap=0;
edge[cnt].next=head[v];
head[v]=cnt++;
}
void bfs()
{
memset(d,-1,sizeof(d));
memset(num,0,sizeof(num));
queue<int >q;
q.push(t);
d[t]=0;
num[0]=1;
while(!q.empty()) {
int i;
int u=q.front();
q.pop();
for(i=head[u]; i!=-1; i=edge[i].next) {
int v=edge[i].v;
if(d[v]==-1) continue;
d[v]=d[u]+1;
num[d[v]]++;
q.push(v);
}
}
}
int isap()
{
memcpy(cur,head,sizeof(cur));
int flow=0, u=pre[s]=s, i;
bfs();
while(d[s]<nv) {
if(u==t) {
int f=inf, pos;
for(i=s; i!=t; i=edge[cur[i]].v) {
if(f>edge[cur[i]].cap) {
f=edge[cur[i]].cap;
pos=i;
}
}
for(i=s; i!=t; i=edge[cur[i]].v) {
edge[cur[i]].cap-=f;
edge[cur[i]^1].cap+=f;
}
flow+=f;
u=pos;
}
for(i=cur[u]; i!=-1; i=edge[i].next) {
if(d[edge[i].v]+1==d[u]&&edge[i].cap)
break;
}
if(i!=-1) {
cur[u]=i;
pre[edge[i].v]=u;
u=edge[i].v;
} else {
if(--num[d[u]]==0) break;
int mind=nv;
for(i=head[u]; i!=-1; i=edge[i].next) {
if(mind>d[edge[i].v]&&edge[i].cap) {
mind=d[edge[i].v];
cur[u]=i;
}
}
d[u]=mind+1;
num[d[u]]++;
u=pre[u];
}
}
return flow;
}
int main()
{
int T,n, m, i, j;
int tt=1;
char str[110];
scanf("%d",&T);
while(T--)
{
scanf("%d %d",&n,&m);
memset(mp,0,sizeof(mp));
for(i=1;i<=n;i++)
{
scanf("%s",str);
for(j=0;j<m;j++)
{
if(str[j]=='E')
mp[i][j+1]=2;
else if(str[j]=='.')
mp[i][j+1]=1;
}
}
cnt=0;
s=0;
t=(n+2)*(m+2)+1;
nv=t+1;
memset(head,-1,sizeof(head));
for(i=0;i<=n+1;i++)
{
for(j=0;j<=m+1;j++)
{
if((i+j)%2==0)
{
if(mp[i][j]==1)
add(i*(m+2)+j+1,t,inf);
else if(mp[i][j]==0)
add(s,i*(m+2)+j+1,inf);
}
else
{
if(mp[i][j]==0)
add(i*(m+2)+j+1,t,inf);
else if(mp[i][j]==1)
{
add(s,i*(m+2)+j+1,inf);
}
}
for(int k=0;k<4;k++)
{
int x=i+jx[k];
int y=j+jy[k];
if(x>=0&&x<=n+1&&y>=0&&y<=m+1)
add(i*(m+2)+j+1,x*(m+2)+y+1,1);
}
}
}
int ans;
ans=isap();
printf("Case %d: %d\n",tt++,(n+1)*(m+2)+(n+2)*(m+1)-ans);
}
return 0;
}

16
HDOJ/4861_autoAC.cpp Normal file
View File

@ -0,0 +1,16 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int main()
{
int k,p;
while(scanf("%d%d",&k,&p)!=EOF)
{
if((k/(p-1))%2==1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}

103
HDOJ/4862_autoAC.cpp Normal file
View File

@ -0,0 +1,103 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std ;
const int N = 2222 ;
const int M = 222222 ;
const int INF = 11111111 ;
struct Edge {
int from , to , next , flow , cap , cost ;
Edge () {}
Edge (int a,int b,int c,int d,int e) {
from = a , to = b , flow = c , cap = d , cost = e ;
}
} edge[M] ;
int head[N] , tot ;
void new_edge ( int from , int to , int flow , int cap , int cost ) {
edge[tot] = Edge ( from , to , flow , cap , cost );
edge[tot].next = head[from] ;
head[from] = tot ++ ;
edge[tot] = Edge ( to , from , 0 , 0 , -cost ) ;
edge[tot].next = head[to] ;
head[to] = tot ++ ;
}
int vis[N] , dis[N] , pre[N] , add[N] ;
queue<int> Q ;
int spfa ( int s , int t , int& flow , int& cost , int n ) {
int i , u , v ;
for ( i = 1 ; i <= n ; i ++ ) dis[i] = INF ;
dis[s] = 0 , add[s] = INF ;
Q.push ( s ) ; vis[s] = 1 ;
while ( !Q.empty () ) {
u = Q.front () ; Q.pop () , vis[u] = 0 ;
for ( i = head[u] ; i != -1 ; i = edge[i].next ) {
Edge e = edge[i] ;
v = e.to ;
if ( e.cap > e.flow && dis[v] > dis[u] + edge[i].cost ) {
dis[v] = dis[u] + edge[i].cost ;
add[v] = min ( add[u] , e.cap - e.flow ) ;
pre[v] = i ;
if ( !vis[v] ) Q.push (v) , vis[v] = 1 ;
}
}
}
if ( dis[t] >= 0 ) return 0 ;
flow += add[t] ; cost += add[t] * dis[t] ;
u = t ;
while ( u != s ) {
edge[pre[u]].flow += add[t] ;
edge[pre[u]^1].flow -= add[t] ;
u = edge[pre[u]].from ;
}
return 1 ;
}
int mincost_maxflow ( int s , int t , int n ) {
int flow = 0 , cost = 0 ;
while ( spfa ( s , t , flow , cost , n ) ) ;
return cost ;
}
char mp[33][33] ;
int cnt ;
int c[33][33][2] ;
int change ( int x , int y , int z ) {
if ( !c[x][y][z] ) c[x][y][z] = ++ cnt ;
return c[x][y][z] ;
}
int main () {
int n , m , k ;
int cas , ca = 0 ;
scanf ( "%d" , &cas ) ;
while ( cas -- ) {
scanf ( "%d%d%d" , &n , &m , &k ) ;
for ( int i = 1 ; i <= n ; i ++ )
scanf ( "%s" , mp[i]+1 ) ;
cnt = tot = 0 ;
memset ( c , 0 , sizeof (c) ) ;
memset ( head , -1 , sizeof ( head ) ) ;
int s , t , temp ;
s = ++ cnt , t = ++ cnt , temp = ++ cnt ;
new_edge ( s , temp , 0 , k , 0 ) ;
for ( int i = 1 ; i <= n ; i ++ )
for ( int j = 1 ; j <= m ; j ++ ) {
new_edge ( change(i,j,0) , change(i,j,1) , 0 , 1 , -INF ) ;
new_edge ( change(i,j,1) , t , 0 , 1 , 0 ) ;
new_edge ( temp , change(i,j,0) , 0 , 1 , 0 ) ;
for ( int k = j + 1 ; k <= m ; k ++ ) {
int add = -(k - j - 1) ;
if ( mp[i][j] == mp[i][k] ) add += mp[i][j] - '0' ;
new_edge ( change(i,j,1) , change(i,k,0) , 0 , 1 , -add ) ;
}
for ( int k = i + 1 ; k <= n ; k ++ ) {
int add = -(k - i - 1) ;
if ( mp[i][j] == mp[k][j] ) add += mp[i][j] - '0' ;
new_edge ( change(i,j,1) , change(k,j,0) , 0 , 1 , -add ) ;
}
}
int fuck = mincost_maxflow ( s , t , cnt ) ;
printf ( "Case %d : " , ++ ca ) ;
if ( fuck > -INF * n * m ) puts ( "-1" ) ;
else printf ( "%d\n" , -(fuck + n * m * INF ) ) ;
}
return 0 ;
}

132
HDOJ/4863_autoAC.cpp Normal file
View File

@ -0,0 +1,132 @@
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <queue>
using namespace std;
#define N 333
#define LL long long
#define mod 10007ll
#define inf 0XFFFFFFF
#define pii pair<int, int>
#define mp make_pair
#define eps 1e-3
int n;
vector<int> node[N];
int sz[N];
int pre(LL dp[]) {
int ret = n;
while (ret > 0 && dp[ret] == 0) ret--;
return ret;
}
int dfs(int u, int fa) {
int ret = 1;
for (int i = 0; i < node[u].size(); i++) {
if (node[u][i] == fa) continue;
int tmp = dfs(node[u][i], u);
sz[u] = max(sz[u], tmp);
ret += tmp;
}
if (fa != -1)
sz[u] = max(sz[u], n - ret);
return ret;
}
LL dp[N][N];
void getdp(int u, int fa) {
for (int i = 0; i < node[u].size(); i++) {
if (node[u][i] == fa) continue;
getdp(node[u][i], u);
}
dp[u][0] = 1;
dp[u][1] = 1;
for (int i = 0; i < node[u].size(); i++) {
int v = node[u][i];
if (v == fa) continue;
int x = pre(dp[u]);
int y = pre(dp[v]);
for (int l1 = x; l1 > 0; l1--) {
for (int l2 = y; l2 > 0; l2--) {
dp[u][l1 + l2] += dp[u][l1] * dp[v][l2];
dp[u][l1 + l2] %= mod;
}
}
}
}
LL work1(int u1, int u2) {
getdp(u1, u2);
getdp(u2, u1);
LL ret = 0;
for (int i = 1; i <= n; i++)
ret = (ret + dp[u1][i] * dp[u2][i]) % mod;
return ret;
}
LL f[N];
LL work(int u) {
getdp(u, -1);
LL ct = 0;
for (int i = 0; i < node[u].size(); i++) {
memset(f, 0, sizeof f);
f[0] = 1;
int v = node[u][i];
for (int j = 0; j < node[u].size(); j++) {
if (i == j) continue;
int l1 = pre(f);
int l2 = pre(dp[node[u][j]]);
for (int x = l1; x >= 0; x--) {
for (int y = l2; y > 0; y--) {
f[x + y] += f[x] * dp[node[u][j]][y];
f[x + y] %= mod;
}
}
}
int l1 = pre(dp[v]);
for (int x = 0; x <= l1; x++) {
for (int y = 0; y < x; y++) {
ct += dp[v][x] * f[y];
ct %= mod;
}
}
}
LL l = 0;
for (int i = 1; i <= n; i++)
l = (l + dp[u][i]) % mod;
return (l + mod - ct) % mod;
}
int Main() {
int T; scanf("%d", &T);
int tt = 0;
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
node[i].clear();
}
memset(sz, 0, sizeof sz);
memset(dp, 0, sizeof dp);
for (int i = 0; i < n - 1; i++) {
int u, v; scanf("%d%d", &u, &v);
node[u].push_back(v);
node[v].push_back(u);
}
dfs(1, -1);
int u1 = 0, u2 = 0;
sz[0] = n + n;
for (int i = 1; i <= n; i++) {
if (sz[i] < sz[u1])
u1 = i;
else if (sz[i] == sz[u1])
u2 = i;
}
cout << "Case " << ++tt << ": ";
if (sz[u1] == sz[u2])
cout << work1(u1, u2) << endl;
else cout << work(u1) << endl;
}
return 0;
}
int main() {
return Main();
}

49
HDOJ/4864_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
struct node
{
int x,y;
} s1[100005],s2[100005];
int cmp(node a,node b)
{
if(a.x == b.x)
return a.y>b.y;
return a.x>b.x;
}
int main()
{
int n,m,i,j,cnt;
__int64 sum;
while(~scanf("%d%d",&n,&m))
{
for(i = 0; i<n; i++)
scanf("%d%d",&s1[i].x,&s1[i].y);
for(i = 0; i<m; i++)
scanf("%d%d",&s2[i].x,&s2[i].y);
sort(s1,s1+n,cmp);
sort(s2,s2+m,cmp);
cnt = sum = 0;
int c[105] = {0};
for(i = 0,j = 0; i<m; i++)
{
while(j<n && s1[j].x>=s2[i].x)
{
c[s1[j].y]++;
j++;
}
for(int k = s2[i].y; k<=100; k++)
{
if(c[k])
{
c[k]--;
sum+=(s2[i].x*500+s2[i].y*2);
cnt++;
break;
}
}
}
printf("%d %I64d\n",cnt,sum);
}
}

92
HDOJ/4865_autoAC.cpp Normal file
View File

@ -0,0 +1,92 @@
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string>
#include <map>
#include <vector>
#define maxn 55
using namespace std;
double dp[55][3];
int pre[55][3];
map<string,int> mp;
string str;
double p1[3][4]={0.6,0.2,0.15,0.05,0.25,0.3,0.2,0.25,0.05,0.1,0.35,0.5};
double p2[3][3]={0.5,0.375,0.125,0.25,0.125,0.625,0.25,0.375,0.375};
void init()
{
mp.insert(make_pair("Dry",0));
mp.insert(make_pair("Dryish",1));
mp.insert(make_pair("Damp",2));
mp.insert(make_pair("Soggy",3));
}
int main()
{
int ncase,T=0;
scanf("%d",&ncase);
init();
while(ncase--)
{
printf("Case #%d:\n",++T);
int n;
scanf("%d",&n);
cin>>str;
for(int i=0;i<=n;i++)
{
for(int j=0;j<3;j++)
dp[i][j]=0;
}
int lab=mp[str];
memset(pre,0,sizeof(pre));
dp[1][0]=0.63*p1[0][lab];
dp[1][1]=0.17*p1[1][lab];
dp[1][2]=0.2*p1[2][lab];
for(int i=2;i<=n;i++)
{
cin>>str;
int lab=mp[str];
for(int j=0;j<3;j++)
{
for(int k=0;k<3;k++)
{
double pp=dp[i-1][k]*p2[k][j]*p1[j][lab];
if(pp>dp[i][j])
{
dp[i][j]=pp;
pre[i][j]=k;
}
}
}
}
vector<int> ans;
double mi=0;
int po;
for(int i=0;i<3;i++)
{
if(dp[n][i]>mi)
{
mi=dp[n][i];
po=i;
}
}
ans.push_back(po);
int now=n;
while(now!=1)
{
po=pre[now][po];
ans.push_back(po);
now--;
}
for(int i=n-1;i>=0;i--)
{
if(ans[i]==0)
printf("Sunny\n");
else if(ans[i]==1)
printf("Cloudy\n");
else
printf("Rainy\n");
}
}
return 0;
}

169
HDOJ/4866_autoAC.cpp Normal file
View File

@ -0,0 +1,169 @@
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define REV( i , n ) for ( int i = n - 1 ; i >= 0 ; -- i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define FOV( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define REPF( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define REPV( i , a , b ) for ( int i = a - 1 ; i >= b ; -- i )
#define CLR( a , x ) memset ( a , x , sizeof a )
#define mid() ( ( l + r ) >> 1 )
typedef long long LL ;
const int MAXN = 100005 ;
const int MAXE = 200005 ;
struct Edge {
int h , c , n ;
Edge () {}
Edge ( int h , int c , int n ) :
h ( h ) , c ( c ) , n ( n ) {}
} ;
struct Seg_Tree {
int Ls , Rs ;
int c ;
LL val ;
} ;
Edge E[MAXE] ;
int H[MAXN] , cntE ;
Seg_ T[MAXN * 38] ;
int idx ;
int a[MAXN] , cnt ;
int Root[MAXN] ;
int N , M , X , P ;
LL Pre ;
int unique ( int a[] , int n ) {
int cnt = 1 ;
sort ( a + 1 , a + n + 1 ) ;
FOR ( i , 2 , n )
if ( a[i] != a[cnt] )
a[++ cnt] = a[i] ;
return cnt ;
}
int lower_bound ( int key ) {
int l = 1 , r = cnt + 1 ;
while ( l < r ) {
int m = mid () ;
if ( a[m] >= key )
r = m ;
else
l = m + 1 ;
}
return l ;
}
int newnode () {
return ++ idx ;
}
void build ( int &o , int l , int r ) {
o = newnode () ;
T[o].c = 0 ;
T[o].val = 0 ;
if ( l == r )
return ;
int m = mid () ;
build ( T[o].Ls , l , m ) ;
build ( T[o].Rs , m + 1 , r ) ;
}
int insert ( int old , int pos , int val , int c ) {
int root = newnode () ;
int now = root ;
int l = 1 , r = cnt ;
T[now].c = T[old].c + c ;
T[now].val = T[old].val + val ;
while ( l < r ) {
int m = mid () ;
if ( pos <= m ) {
T[now].Ls = newnode () ;
T[now].Rs = T[old].Rs ;
now = T[now].Ls ;
old = T[old].Ls ;
r = m ;
}
else {
T[now].Ls = T[old].Ls ;
T[now].Rs = newnode () ;
now = T[now].Rs ;
old = T[old].Rs ;
l = m + 1 ;
}
T[now].c = T[old].c + c ;
T[now].val = T[old].val + val ;
}
return root ;
}
LL query ( int now , int kth ) {
LL ans = 0 ;
int l = 1 , r = cnt ;
while ( l < r ) {
int m = mid () ;
if ( kth <= T[T[now].Ls].c ) {
now = T[now].Ls ;
r = m ;
}
else {
ans += T[T[now].Ls].val ;
kth -= T[T[now].Ls].c ;
now = T[now].Rs ;
l = m + 1 ;
}
}
if ( T[now].c && kth )
ans += T[now].val / T[now].c * kth ;
return ans ;
}
void init () {
cntE = 0 ;
CLR ( H , -1 ) ;
}
void addedge ( int x , int h , int c ) {
E[cntE] = Edge ( h , c , H[x] ) ;
H[x] = cntE ++ ;
}
void solve () {
int l , r , h ;
init () ;
idx = 0 ;
cnt = 0 ;
Pre = 1 ;
FOR ( i , 1 , N ) {
scanf ( "%d%d%d" , &l , &r , &h ) ;
addedge ( l , h , 1 ) ;
addedge ( r + 1 , h , -1 ) ;
a[++ cnt] = h ;
}
cnt = unique ( a , cnt ) ;
build ( Root[0] , 1 , cnt ) ;
FOR ( x , 1 , X ) {
if ( ~H[x] ) {
int flag = 0 ;
for ( int i = H[x] ; ~i ; i = E[i].n ) {
h = E[i].h ;
if ( !flag ) {
Root[x] = insert ( Root[x - 1] , lower_bound ( h ) , E[i].c * h , E[i].c ) ;
flag = 1 ;
}
else
Root[x] = insert ( Root[x] , lower_bound ( h ) , E[i].c * h , E[i].c ) ;
}
}
else {
Root[x] = newnode () ;
T[Root[x]] = T[Root[x - 1]] ;
}
}
int pos , a , b , c ;
REP ( i , M ) {
scanf ( "%d%d%d%d" , &pos , &a , &b , &c ) ;
int kth = ( a * Pre + b ) % c ;
LL score = query ( Root[pos] , kth ) ;
if ( Pre > P )
score <<= 1 ;
printf ( "%I64d\n" , score ) ;
Pre = score ;
}
}
int main () {
while ( ~scanf ( "%d%d%d%d" , &N , &M , &X , &P ) )
solve () ;
return 0 ;
}

134
HDOJ/4867_autoAC.cpp Normal file
View File

@ -0,0 +1,134 @@
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<cmath>
#include<vector>
#define inf 0x3f3f3f3f
#define Inf 0x3FFFFFFFFFFFFFFFLL
#define eps 1e-9
#define pi acos(-1.0)
using namespace std;
typedef long long ll;
const int maxn=20000;
const int mod=1000000007;
vector<pair<int,int> >tree[maxn<<2];
map<int,int>mp;
int mlen,a[maxn];
vector<pair<int,int> > getpre(int n)
{
vector<pair<int,int> >res;
for(int i=9;i>=0;--i)
if(n&(1<<i))
{
res.push_back(make_pair(((n>>i)^1)<<4|i,1));
}
res.push_back(make_pair(n<<4,1));
return res;
}
int cal(int x,int y)
{
int xlen=x&0xf,ylen=y&0xf;
if(xlen>ylen) {swap(x,y);swap(xlen,ylen);}
x>>=4;y>>=4;
int m=(ylen-xlen);
x>>=m;
mlen=xlen;
return (x^y)<<4|ylen;
}
void PushUp(int rt)
{
tree[rt].clear();
mp.clear();
int ls=rt<<1,rs=rt<<1|1,v,num,pos,tot=0;
ll A,B;
for(int i=0;i<(int)tree[ls].size();++i)
for(int j=0;j<(int)tree[rs].size();++j)
{
v=cal(tree[ls][i].first,tree[rs][j].first);
A=tree[ls][i].second;B=tree[rs][j].second;
num=A*(1<<mlen)%mod*B%mod;
if(mp.find(v)==mp.end())
{
mp[v]=tot++;
tree[rt].push_back(make_pair(v,num));
}
else
{
pos=mp[v];
tree[rt][pos].second+=num;
if(tree[rt][pos].second>=mod) tree[rt][pos].second-=mod;
}
}
}
void build(int l,int r,int rt)
{
if(l==r)
{
tree[rt]=getpre(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 p,int l,int r,int rt,int v)
{
if(l==r)
{
tree[rt]=getpre(v);
return ;
}
int m=(l+r)>>1;
if(m>=p) Update(p,l,m,rt<<1,v);
else Update(p,m+1,r,rt<<1|1,v);
PushUp(rt);
}
int Query(int val)
{
int ans=0,len;
pair<int,int>pii;
for(int i=0;i<(int)tree[1].size();++i)
{
pii=tree[1][i];
len=pii.first&0xf;
if((pii.first>>4)==(val>>len))
{
ans+=pii.second;
if(ans>=mod) ans-=mod;
}
}
return ans;
}
int main()
{
char str[10];
int t,n,m;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i)
scanf("%d",&a[i]);
build(1,n,1);
int x,y;
while(m--)
{
scanf("%s%d",str,&x);
if(str[0]=='Q')
printf("%d\n",Query(x));
else
{
scanf("%d",&y);
Update(x+1,1,n,1,y);
}
}
}
return 0;
}

278
HDOJ/4868_autoAC.cpp Normal file
View File

@ -0,0 +1,278 @@
#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int N=10010;
const int M=35;
char html[M][N],stored[M][N],sta1[N][M];
char mapping[M][M][2][M];
int mapNum[M],sta2[N];
void getHTML(int n)
{
int j,i=0,flag=1;
char beginTag[M],tag[M];
getchar();
while(1)
{
html[n][i]=getchar();
if(html[n][i]=='<')
{
j=0;
while(html[n][++i]=getchar())
{
if(html[n][i]=='/')continue;
if(html[n][i]==' '||html[n][i]=='>')break;
tag[j++]=html[n][i];
}
tag[j]='\0';
if(flag==1)
{
strcpy(beginTag,tag);
flag=0;
}
else if(!strcmp(tag,beginTag))
{
html[n][++i]='\0';
return;
}
}
i++;
}
}
void getMapping(int n,int m)
{
int i,j;
char mp[100];
cin>>mp;
for(i=0; mp[i]!='-'; i++)
mapping[n][m][0][i]=mp[i];
mapping[n][m][0][i]='\0';
for(j=0,i++; i<strlen(mp); i++,j++)
mapping[n][m][1][j]=mp[i];
mapping[n][m][1][j]='\0';
}
void getTag(int n,int i,char tag[])
{
int j=0;
while(1)
{
i++;
if(html[n][i]=='/')continue;
if(html[n][i]==' '||html[n][i]=='>')break;
tag[j++]=html[n][i];
}
tag[j]='\0';
}
int getId(int n,int i,char id[])
{
int j;
id[0]='\0';
char tmp[M];
while(html[n][i]==' ')
{
j=0;
while(html[n][++i]!='=')
tmp[j++]=html[n][i];
tmp[j]='\0';
if(!strcmp(tmp,"id"))
{
i++;
j=0;
while(html[n][++i]!='"')
id[j++]=html[n][i];
id[j]='\0';
}
else
{
i++;
while(html[n][++i]!='"');
}
i++;
}
return i;
}
void store(int n,int i,int j,char tag[])
{
stored[j][0]='\0';
int k,y=0,flag=0,len=strlen(tag);
for(i++;; i++)
{
k=0;
if(html[n][i]=='<')
for(; k<len; k++)
if(tag[k]!=html[n][i+1+k])break;
if(k==len)flag++;
k=0;
if(html[n][i]=='<'&&html[n][i+1]=='/')
for(; k<len; k++)
if(tag[k]!=html[n][i+2+k])break;
if(k==len)
{
if(!flag)
{
stored[j][y]='\0';
return;
}
else flag--;
}
stored[j][y++]=html[n][i];
}
}
bool isStructure(int n,int m)
{
int i,j,k,ii,flag=0,top=-1;
char tag[M],id[M],tag2[M],id2[M];
int len1=strlen(html[n]);
for(i=k=0; i<len1;)
{
ii=i;
while(html[n][i]==' '||html[n][i]=='\n')i++;
while(html[m][k]!='<')k++;
getTag(n,i,tag);
getTag(m,k,tag2);
if(strcmp(tag,tag2)||html[n][i+1]!=html[m][k+1])
{
if(!strcmp(tag,tag2))sta2[top]++;
if(!flag)
{
return false;
}
while(html[m][k]!='>')k++;
i=ii;
continue;
}
if(html[n][i+1]=='/')
{
if(!sta2[top])
{
i+=strlen(tag)+3;
flag--;
}
else sta2[top]--;
k+=strlen(tag)+3;
}
else
{
i+=strlen(tag)+1;
k+=strlen(tag2)+1;
if(html[n][i]==' ')
{
if(html[m][k]!=' ')
{
if(!flag)
{
return false;
}
while(html[m][k]!='>')k++;
i=ii;
continue;
}
i=getId(n,i,id);
k=getId(m,k,id2);
if(strcmp(id,id2))
{
if(!flag)
{
return false;
}
while(html[m][k]!='>')k++;
i=ii;
continue;
}
}
for(j=0; j<mapNum[n]; j++)
if(!strcmp(id,mapping[n][j][0]))
break;
if(html[n][i]=='/')
{
i+=2;
k+=2;
}
else //<xx>
{
if(j!=mapNum[n])
{
strcpy(sta1[++top],tag);
flag++;
sta2[top]=0;
for(j=0; j<mapNum[n]; j++)
if(!strcmp(id,mapping[n][j][0]))
store(m,k,j,tag);
}
i++;
k++;
}
}
}
return true;
}
void output(int n)
{
int i,j,k,ii;
char tag[M];
int len1=strlen(html[0]);
for(i=0; i<len1;)
{
while(i<len1&&html[0][i]!='<')
putchar(html[0][i++]);
if(i==len1)break;
getTag(0,i,tag);
for(j=0; j<mapNum[n]; j++)
if(!strcmp(tag,mapping[n][j][1]))
break;
if(j==mapNum[n])
{
putchar(html[0][i++]);
continue;
}
else
{
int len=strlen(tag);
ii=i;
for(i+=len+1;; i++)
{
k=0;
if(html[0][i]=='<'&&html[0][i+1]=='/')
for(; k<len; k++)
if(tag[k]!=html[0][i+2+k])break;
if(k==len)break;
}
while(html[0][ii]!='>')
putchar(html[0][ii++]);
putchar(html[0][ii++]);
cout<<stored[j];
while(html[0][i]!='>')
putchar(html[0][i++]);
putchar(html[0][i++]);
}
}
}
int main()
{
int t,ca=1;
scanf("%d",&t);
while(t--)
{
int i,j,n,m;
getHTML(0);
scanf("%d",&n);
for(i=1; i<=n; i++)
{
getHTML(i);
scanf("%d",&mapNum[i]);
for(j=0; j<mapNum[i]; j++)
getMapping(i,j);
}
getHTML(n+1);
printf("Case #%d:\n",ca++);
for(i=1; i<=n; i++)
if(isStructure(i,n+1))
{
output(i);
break;
}
if(i==n+1)printf("Can't Identify\n");
else putchar('\n');
}
return 0;
}

56
HDOJ/4869_autoAC.cpp Normal file
View File

@ -0,0 +1,56 @@
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define mod 1000000009
#define LL __int64
#define maxn 100000+5
LL f[maxn];
void set()
{
int i;
f[0] = 1;
for(i = 1; i<maxn; i++)
f[i] = (f[i-1]*i)%mod;
}
LL quickmod(LL a,LL b)
{
LL ans = 1;
while(b)
{
if(b&1)
{
ans = (ans*a)%mod;
b--;
}
b/=2;
a = ((a%mod)*(a%mod))%mod;
}
return ans;
}
int main()
{
int n,m,i,j,k,l,r,x,ll,rr;
set();
while(~scanf("%d%d",&n,&m))
{
l = r = 0;
for(i = 0; i<n; i++)
{
scanf("%d",&x);
if(l>=x) ll = l-x;
else if(r>=x) ll = ((l%2)==(x%2))?0:1;
else ll = x-r;
if(r+x<=m) rr = r+x;
else if(l+x<=m) rr = (((l+x)%2) == (m%2)?m:m-1);
else rr = 2*m-(l+x);
l = ll,r = rr;
}
LL sum = 0;
for(i = l; i<=r; i+=2)
sum+=((f[m]%mod)*(quickmod((f[i]*f[m-i])%mod,mod-2)%mod))%mod;
printf("%I64d\n",sum%mod);
}
return 0;
}

49
HDOJ/4870_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF ((LL)100000000000000000)
#define inf (-((LL)1<<40))
#define lson k<<1, L, mid
#define rson k<<1|1, mid+1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b; }
typedef long long LL;
const int MAXN = 255;
const int MAXM = 110000;
const double eps = 1e-12;
double t[30];
int main()
{
double p;
while(~scanf("%lf", &p))
{
t[0] = 0;
t[1] = 1 / p;
t[2] = 1 / p + 1 / p / p;
for(int i=3;i<=20;i++)
{
t[i] = 1 / p * t[i-1] + 1 / p - (1-p) / p * t[i-3];
}
double ans = 2 *t[19] + t[20] - t[19];
printf("%lf\n", ans);
}
return 0;
}

232
HDOJ/4871_autoAC.cpp Normal file
View File

@ -0,0 +1,232 @@
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef __int64 LL;
const int INF=100011122;
const double INFF=1e100;
const double eps=1e-8;
const LL mod=1000000007;
const int NN=30010;
const int MM=60010;
struct G
{
int v,w,next;
}E1[MM*2],E[NN*2];
int p[NN],T;
int p1[NN],T1;
bool inq[NN];
int dis[NN];
struct node
{
int x,dis;
node(int a=0,int b=0):x(a),dis(b){}
bool operator<(const node &tt)const
{
return dis>tt.dis;
}
};
int ans,limit;
LL ans_cnt;
int si[NN],m_si[NN],a[NN],tol;
bool vis[NN];
int re[NN],re_num[NN],t_re[NN],t_re_num[NN];
void add1(int u,int v,int w)
{
E1[T1].v=v;
E1[T1].w=w;
E1[T1].next=p1[u];
p1[u]=T1++;
}
void add(int u,int v,int w)
{
E[T].v=v;
E[T].w=w;
E[T].next=p[u];
p[u]=T++;
}
void dij(int st,int n)
{
priority_queue<node>q;
int i,j,v;
for(i=1;i<=n;i++)
{
dis[i]=INF;
inq[i]=false;
}
dis[st]=0;
q.push( node(st,0) );
while(!q.empty())
{
node ix = q.top();
q.pop();
if( inq[ ix.x ] )continue;
inq[ ix.x ]=true;
for(i=p1[ix.x];i+1;i=E1[i].next)
{
v=E1[i].v;
if(dis[v]>dis[ix.x]+E1[i].w)
{
dis[v]=dis[ix.x]+E1[i].w;
q.push( node(v,dis[v]) );
}
}
}
memset(p,-1,sizeof(p));
T=0;
for(i=1;i<=n;i++)
inq[i]=false;
inq[st]=true;
for(i=1;i<=n;i++)
{
for(j=p1[i];j+1;j=E1[j].next)
{
v=E1[j].v;
if(dis[i]+E1[j].w==dis[v] && !inq[v])
{
inq[v]=true;
add(i,v,E1[j].w);
add(v,i,E1[j].w);
}
}
}
}
void dfs_fr(int u,int fa)
{
int i,v;
si[u]=1;
m_si[u]=0;
a[++tol]=u;
for(i=p[u];i+1;i=E[i].next)
{
v=E[i].v;
if(v==fa || vis[v])continue;
dfs_fr(v,u);
si[u]+=si[v];
m_si[u]=max(m_si[u],si[v]);
}
}
void dfs(int u,int fa,int ge,int d)
{
int i,v;
if(d>t_re[ge])
{
t_re[ge]=d;
t_re_num[ge]=1;
}
else if(d==t_re[ge])
t_re_num[ge]++;
for(i=p[u];i+1;i=E[i].next)
{
v=E[i].v;
if(v==fa || vis[v])continue;
dfs(v,u,ge+1,d+E[i].w);
}
}
void goo(int x,LL ci)
{
if(x>ans)
{
ans=x;
ans_cnt=ci;
}
else if(x==ans)
{
ans_cnt+=ci;
}
}
void solve(int root)
{
tol=0;
dfs_fr(root,-1);
int i,j,t,v,new_root=root;
int m=m_si[root];
for(i=1;i<=tol;i++)
{
t=max(m_si[a[i]],tol-si[a[i]]);
if(m>t)
{
m=t;
new_root=a[i];
}
}
dfs_fr(new_root,-1);
m = m_si[new_root];
for(i=1;i<=m;i++)
{
re[i]=-INF;
re_num[i]=0;
}
for(i=p[new_root];i+1;i=E[i].next)
{
v=E[i].v;
if(vis[v])continue;
for(j=1;j<=si[v];j++)
{
t_re[j]=-INF;
t_re_num[j]=0;
}
dfs(v,new_root,1,E[i].w);
for(j=1;j<=si[v];j++)
{
if(j+1==limit)
goo(t_re[j],t_re_num[j]);
t=limit-1-j;
if(1<=t && t<=m)
goo(t_re[j]+re[t],(LL)t_re_num[j]*re_num[t]);
}
for(j=1;j<=si[v];j++)
{
if(re[j]<t_re[j])
{
re_num[j]=t_re_num[j];
re[j]=t_re[j];
}
else if(re[j]==t_re[j])
re_num[j]+=t_re_num[j];
}
}
vis[new_root]=true;
for(i=p[new_root];i+1;i=E[i].next)
{
v=E[i].v;
if(vis[v])continue;
solve(v);
}
}
int main()
{
int cas;
int n,m,k,u,v,w;
scanf("%d",&cas);
while(cas--)
{
scanf("%d%d%d",&n,&m,&k);
memset(p1,-1,sizeof(p1));
T1=0;
while(m--)
{
scanf("%d%d%d",&u,&v,&w);
add1(u,v,w);
add1(v,u,w);
}
dij(1,n);
ans=-1;
memset(vis,false,sizeof(vis));
limit=k;
solve(1);
printf("%d %I64d\n",ans,ans_cnt);
}
return 0;
}

90
HDOJ/4872_autoAC.cpp Normal file
View File

@ -0,0 +1,90 @@
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
#define maxn 105
#define FOR(i,a,b) for(int i=a;i<=b;++i)
typedef __int64 LL;
int n,m,q;
LL flag1z[maxn][maxn][maxn];
LL flag1f[maxn][maxn][maxn];
LL flag2z[maxn][maxn][maxn];
LL flag2f[maxn][maxn][maxn];
LL dpz[maxn][maxn][maxn];
LL dpf[maxn][maxn][maxn];
LL ans[maxn][maxn][maxn];
LL si[maxn][maxn][maxn];
LL yoz[maxn][maxn][maxn];
LL rec[maxn][maxn][maxn];
LL tri[maxn][maxn][maxn];
LL d[maxn][maxn][maxn];
void init()
{
memset(flag1z,0,sizeof(flag1z));
memset(flag1f,0,sizeof(flag1f));
memset(flag2z,0,sizeof(flag2z));
memset(flag2f,0,sizeof(flag2f));
}
void solve1(int x,int y,int z,int a)
{
int i,j,k;
flag1z[x][y][z]++;
flag1z[x+a][y+a][z+a]--;
flag2z[x][y+1][z]++;
flag2z[x+a][y+a+1][z+a]--;
flag1f[x+a][y][z]++;
flag1f[x+a][y+a][z+a]--;
flag2f[x+a][y+a+1][z]++;
flag2f[x+a][y+a+1][z+a]--;
}
void solve2()
{
int i,j,k;
FOR(i,1,n) FOR(j,1,n) FOR(k,1,n){
flag1z[i][j][k]+=flag1z[i-1][j-1][k-1];
flag2z[i][j][k]+=flag2z[i-1][j-1][k-1];
flag1f[i][j][k]+=flag1f[i][j-1][k-1];
flag2f[i][j][k]+=flag2f[i][j][k-1];
}
FOR(i,1,n) FOR(j,1,n) FOR(k,1,n){
dpz[i][j][k]=dpz[i-1][j][k]+flag1z[i][j][k]-flag1f[i][j][k];
dpf[i][j][k]=dpf[i-1][j-1][k]+flag2z[i][j][k]-flag2f[i][j][k];
ans[i][j][k]=ans[i][j-1][k]+dpz[i][j][k]-dpf[i][j][k];
}
FOR(i,1,n) FOR(j,1,n) FOR(k,1,n){
d[i][j][k]=d[i][j][k-1]+ans[i][j][k];
yoz[i][j][k]=yoz[i][j-1][k-1]+d[i][j][k];
si[i][j][k]=si[i-1][j-1][k-1]+yoz[i][j][k];
rec[i][j][k]=rec[i][j-1][k]+d[i][j][k];
tri[i][j][k]=tri[i-1][j-1][k]+rec[i][j][k];
}
FOR(i,1,n) FOR(j,1,n) FOR(k,1,n){
yoz[i][j][k]+=yoz[i-1][j][k];
rec[i][j][k]+=rec[i-1][j][k];
}
}
LL solve3(int x,int y,int z,int a)
{
return si[x+a-1][y+a-1][z+a-1]-si[x-1][y-1][z-1]-(yoz[x+a-1][y-1][z-1]-yoz[x-1][y-1][z-1])-(tri[x+a-1][y+a-1][z-1]-(rec[x+a-1][y-1][z-1]-rec[x-1][y-1][z-1])-tri[x-1][y-1][z-1]);
}
int main()
{
int i,j,k;
int x,y,z,a;
while(scanf("%d%d%d",&n,&m,&q)!=EOF)
{
for(i=0;i<m;i++)
{
scanf("%d%d%d%d",&x,&y,&z,&a);
solve1(x,y,z,a);
}
solve2();
for(i=0;i<q;i++)
{
scanf("%d%d%d%d",&x,&y,&z,&a);
printf("%I64d\n",solve3(x,y,z,a));
}
}
return 0;
}

234
HDOJ/4873_autoAC.cpp Normal file
View File

@ -0,0 +1,234 @@
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 10005;
struct bign {
int len, num[MAXN];
bign () {
len = 0;
memset(num, 0, sizeof(num));
}
bign (int number) {*this = number;}
bign (const char* number) {*this = number;}
void DelZero ();
void Put ();
void operator = (int number);
void operator = (char* number);
bool operator < (const bign& b) const;
bool operator > (const bign& b) const { return b < *this; }
bool operator <= (const bign& b) const { return !(b < *this); }
bool operator >= (const bign& b) const { return !(*this < b); }
bool operator != (const bign& b) const { return b < *this || *this < b;}
bool operator == (const bign& b) const { return !(b != *this); }
void operator ++ ();
void operator -- ();
bign operator + (const int& b);
bign operator + (const bign& b);
bign operator - (const int& b);
bign operator - (const bign& b);
bign operator * (const int& b);
bign operator * (const bign& b);
bign operator / (const int& b);
//bign operator / (const bign& b);
int operator % (const int& b);
};
/*Code*/
const int maxn = 5000;
int cnt, num[maxn];
void divfact (int n) {
int m = (int)sqrt(n + 0.5);
for (int i = 2; i <= m; i++) {
if (n % i)
continue;
num[cnt++] = i;
while (n % i == 0)
n /= i;
}
if (n != 1)
num[cnt++] = n;
}
bign power (bign x, int d) {
bign ans = 1;
while (d) {
if (d & 1)
ans = ans * x;
x = x * x;
d /= 2;
}
return ans;
}
int main () {
int N, D;
while (scanf("%d%d", &N, &D) == 2 && N + D) {
cnt = 0;
bign q = N;
q = power(q, D) * 9;
bign p = D * (D - 1) / 2;
p = p * (N + 4);
p = p * (N + 4);
divfact(N);
num[cnt++] = 3;
for (int i = 0; i < cnt; i++) {
while (p % num[i] == 0 && q % num[i] == 0) {
p = p / num[i];
q = q / num[i];
}
}
if (p != q) {
p.Put();
printf("/");
q.Put();
} else
printf("1");
printf("\n");
}
return 0;
}
void bign::DelZero () {
while (len && num[len-1] == 0)
len--;
if (len == 0) {
num[len++] = 0;
}
}
void bign::Put () {
for (int i = len-1; i >= 0; i--)
printf("%d", num[i]);
}
void bign::operator = (char* number) {
len = strlen (number);
for (int i = 0; i < len; i++)
num[i] = number[len-i-1] - '0';
DelZero ();
}
void bign::operator = (int number) {
len = 0;
while (number) {
num[len++] = number%10;
number /= 10;
}
DelZero ();
}
bool bign::operator < (const bign& b) const {
if (len != b.len)
return len < b.len;
for (int i = len-1; i >= 0; i--)
if (num[i] != b.num[i])
return num[i] < b.num[i];
return false;
}
void bign::operator ++ () {
int s = 1;
for (int i = 0; i < len; i++) {
s = s + num[i];
num[i] = s % 10;
s /= 10;
if (!s) break;
}
while (s) {
num[len++] = s%10;
s /= 10;
}
}
void bign::operator -- () {
if (num[0] == 0 && len == 1) return;
int s = -1;
for (int i = 0; i < len; i++) {
s = s + num[i];
num[i] = (s + 10) % 10;
if (s >= 0) break;
}
DelZero ();
}
bign bign::operator + (const int& b) {
bign a = b;
return *this + a;
}
bign bign::operator + (const bign& b) {
int bignSum = 0;
bign ans;
for (int i = 0; i < len || i < b.len; i++) {
if (i < len) bignSum += num[i];
if (i < b.len) bignSum += b.num[i];
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
}
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
}
return ans;
}
bign bign::operator - (const int& b) {
bign a = b;
return *this - a;
}
bign bign::operator - (const bign& b) {
int bignSub = 0;
bign ans;
for (int i = 0; i < len || i < b.len; i++) {
bignSub += num[i];
bignSub -= b.num[i];
ans.num[ans.len++] = (bignSub + 10) % 10;
if (bignSub < 0) bignSub = -1;
}
ans.DelZero ();
return ans;
}
bign bign::operator * (const int& b) {
long long bignSum = 0;
bign ans;
ans.len = len;
for (int i = 0; i < len; i++) {
bignSum += (long long)num[i] * b;
ans.num[i] = bignSum % 10;
bignSum /= 10;
}
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
}
return ans;
}
bign bign::operator * (const bign& b) {
bign ans;
ans.len = 0;
for (int i = 0; i < len; i++){
int bignSum = 0;
for (int j = 0; j < b.len; j++){
bignSum += num[i] * b.num[j] + ans.num[i+j];
ans.num[i+j] = bignSum % 10;
bignSum /= 10;
}
ans.len = i + b.len;
while (bignSum){
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
}
}
return ans;
}
bign bign::operator / (const int& b) {
bign ans;
int s = 0;
for (int i = len-1; i >= 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;
s %= b;
}
ans.len = len;
ans.DelZero ();
return ans;
}
int bign::operator % (const int& b) {
bign ans;
int s = 0;
for (int i = len-1; i >= 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;
s %= b;
}
return s;
}

80
HDOJ/4876_autoAC.cpp Normal file
View File

@ -0,0 +1,80 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int n,k,l,r;
int vis[500],a[500],tem[500],s[500];
void set(int len,int sum)
{
vis[sum] = 1;
if(len == k)
return ;
set(len+1,sum^tem[len]);
set(len+1,sum);
}
int check()
{
memset(vis,0,sizeof(vis));
set(0,0);
for(int i = l; i<=r; i++)
if(!vis[i])
return 0;
return 1;
}
void solve()
{
if(!check()) return ;
int i,j;
for(i = 0; i<k; i++)
s[i] = tem[i];
do
{
memset(vis,0,sizeof(vis));
for(i = 0; i<k; i++)
{
int ans = 0;
for(j = i; j<k+i; j++)
{
ans^=s[(j%k)];
vis[ans] = 1;
}
}
for(i = l; i<=128; i++)
if(!vis[i])
{
r = max(r,i-1);
break;
}
}
while(next_permutation(s+1,s+k));
}
void dfs(int now,int len)
{
if(len == k)
{
solve();
return ;
}
for(int i = now; i<n; i++)
{
tem[len] = a[i];
dfs(i+1,len+1);
}
}
int main()
{
int i,j;
while(~scanf("%d%d%d",&n,&k,&l))
{
for(i = 0; i<n; i++)
scanf("%d",&a[i]);
sort(a,a+n);
r = l-1;
dfs(0,0);
if(r<l)
printf("0\n");
else
printf("%d\n",r);
}
return 0;
}

175
HDOJ/4878_autoAC.cpp Normal file
View File

@ -0,0 +1,175 @@
#pragma comment(linker, "/STACK:16777216")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
#include <vector>
#define inf 0x0f0f0f0f
#define in freopen("data.txt", "r", stdin);
#define pb push_back
using namespace std;
typedef long long LL;
const int maxnode = 44;
const int sigma_size = 26;
int prime[maxnode], vis[1111];
void getPrime() {
int cnt = 0;
for(int i = 2; i < 1111 && cnt <= 40; i++) {
if(!vis[i]) prime[++cnt] = i;
for(int j = i*i; j < 1111; j += i)
vis[j] = 1;
}
}
struct Node {
int len, n;
Node(int len, int n): len(len), n(n) {}
};
int ch[maxnode][sigma_size], sz, f[maxnode];
vector<Node> vec[maxnode];
struct Matrix {
int a[44][44];
} xx[200], E0;;
void maMul(Matrix x, Matrix y, Matrix &res, int mod) {
for(int i = 0; i < sz; i++)
for(int j = 0; j < sz; j++) {
res.a[i][j] = 0;
for(int k = 0; k < sz; k++) {
res.a[i][j] += x.a[i][k]*y.a[k][j]%mod;
if(res.a[i][j] >= mod)
res.a[i][j] -= mod;
}
}
}
struct AC {
void init() {
sz = 1;
memset(ch[0], 0, sizeof ch[0]);
vec[0].clear();
}
int idx(char ch) {
return ch - 'A';
}
void insert(char *s, int x) {
int u = 0, len = 0;
for(int i = 0; s[i]; i++, len++) {
int c = idx(s[i]);
if(!ch[u][c]) {
memset(ch[sz], 0, sizeof ch[sz]);
vec[sz].clear();
ch[u][c] = sz++;
}
u = ch[u][c];
}
vec[u].pb(Node(len, prime[x]));
}
void getFail() {
queue<int> q;
f[0] = 0;
for(int c = 0; c < sigma_size; c++) {
int u = ch[0][c];
if(u) {
f[u] = 0;
q.push(u);
}
}
while(!q.empty()) {
int r = q.front();
q.pop();
for(int c = 0; c < sigma_size; c++) {
int u = ch[r][c];
if(!u) {
ch[r][c] = ch[f[r]][c];
continue;
}
q.push(u);
int v = f[r];
while(v && !ch[v][c]) v = f[v];
f[u] = ch[v][c];
}
}
}
void getMat(int x, int mod) {
for(int i = 0; i < sz; i++) for(int j = 0; j < sz; j++) xx[x].a[i][j] = 0;
for(int u = 0; u < sz; u ++)
for(int c = 0; c < sigma_size; c++) {
int v = ch[u][c];
int tv = v;
int res = 1;
while(tv) {
for(int i = 0; i < (int)vec[tv].size(); i++) {
(res *= ((LL)(vec[tv][i].len+x)*vec[tv][i].n%mod))%=mod;
}
tv = f[tv];
}
xx[x].a[v][u] += res;
if(xx[x].a[v][u] >= mod) xx[x].a[v][u] -= mod;
}
}
} solver;
int N;
LL L;
int M[] = {163, 173, 179};
int ans[3], a[3];
int exgcd(int a, int b, int &x, int &y) {
if(!b) {
x = 1, y = 0;
return a;
} else {
int tmp = exgcd(b, a%b, y, x);
y -= (a/b)*x;
return tmp;
}
}
void powmod(Matrix x, LL n, Matrix &res, int mod) {
res = E0;
while(n) {
if(n&1) maMul(res, x, res, mod);
maMul(x, x, x, mod);
n >>= 1;
}
}
int solve() {
solver.getFail();
int mul = 1, res = 0;
for(int i = 0; i < 3; i++) mul *= M[i];
for(int i = 0; i < 3; i++) {
a[i] = mul/M[i];
Matrix tmp1, tmp2;
tmp1 = tmp2 = E0;
LL lv = L%M[i];
for(int k = M[i]; k >= 1; k--) {
solver.getMat(k, M[i]);
maMul(tmp1, xx[k], tmp1, M[i]);
if(k <= lv)
maMul(tmp2, xx[k], tmp2, M[i]);
}
powmod(tmp1, L/M[i], tmp1, M[i]);
maMul(tmp2, tmp1, tmp1, M[i]);
ans[i] = 0;
for(int k = 0; k < sz; k++) {
ans[i] += tmp1.a[k][0];
if(ans[i] >= M[i]) ans[i] -= M[i];
}
int xx, yy;
exgcd(a[i], M[i], xx, yy);
res += a[i]*ans[i]%mul*(xx%M[i])%mul;
if(res >= mul)
res -= mul;
}
return (res+mul)%mul;
}
int main() {
getPrime();
int kase = 0;
for(int i = 0; i < 44; i++) for(int j = 0; j < 44; j++) E0.a[i][j] = i == j;
while(scanf("%d%I64d", &N, &L) == 2) {
solver.init();
for(int i = 1; i <= N; i++) {
char s[44];
scanf("%s", s);
solver.insert(s, i);
}
printf("Case #%d: %d\n", ++kase, solve());
}
return 0;
}

128
HDOJ/4879_autoAC.cpp Normal file
View File

@ -0,0 +1,128 @@
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<stack>
#include<iostream>
#include<queue>
#include<cmath>
#include<string>
#include<set>
#include<map>
using namespace std;
const int maxn = 200000 + 5;
const int INF = 1000000000;
const int Mod = 1000000000 + 7;
typedef long long LL;
typedef pair<LL, LL> P;
struct Node{
LL x, y;
int num;
Node(){}
Node(LL x, LL y, int num){
this -> x = x;
this -> y = y;
this -> num = num;
}
};
map<LL, set<int> > Mx, My;
set<int>::iterator it;
int fa[maxn];
Node pos[maxn];
int cnt;
int Find(int x){return fa[x]==x?x:fa[x]=Find(fa[x]);}
int main(){
int n, m;
while(scanf("%d%d", &n, &m) != EOF){
Mx.clear();
My.clear();
for(int i = 1;i <= n;i++){
LL x, y;
scanf("%I64d%I64d", &x, &y);
pos[i] = Node(x, y, 1);
fa[i] = i;
Mx[x].insert(i);
My[y].insert(i);
}
cnt = n+1;
int t;
scanf("%d", &t);
LL lastans = 0;
while(t--){
char str[5];
scanf("%s", str);
if(str[0]=='Q'){
int x;
scanf("%d", &x);
x = x^lastans;
int X = Find(x);
Node& tem = pos[X];
LL row = tem.x;
LL col = tem.y;
int num = tem.num;
lastans = 0;
int total = 0;
for(it = Mx[row].begin();it != Mx[row].end();it++){
Node& tem = pos[*it];
LL y = tem.y;
My[y].erase(*it);
int num = tem.num;
LL der = abs(y-col)%Mod;
lastans = (lastans + (der*der)%Mod * num) % Mod;
fa[*it] = cnt;
total += num;
}
for(it = My[col].begin();it != My[col].end();it++){
Node& tem = pos[*it];
LL x = tem.x;
Mx[x].erase(*it);
int num = tem.num;
LL der = (abs(x-row))%Mod;
lastans = (lastans + (der*der)%Mod*num) % Mod;
fa[*it] = cnt;
total += num;
}
fa[cnt] = cnt;
pos[cnt] = Node(row, col, total);
Mx[row].clear();
My[col].clear();
Mx[row].insert(cnt);
My[col].insert(cnt);
cnt++;
printf("%I64d\n", lastans);
}
else{
int x;
LL d;
scanf("%d%I64d", &x, &d);
x = x^lastans;
int X = Find(x);
Node& tem = pos[X];
LL nx = tem.x;
LL ny = tem.y;
tem.num--;
if(tem.num==0){
Mx[nx].erase(X);
My[ny].erase(X);
}
if(str[0]=='U'){
nx -= d;
}
else if(str[0]=='L'){
ny -= d;
}
else if(str[0]=='D'){
nx += d;
}
else{
ny += d;
}
fa[x] = x;
pos[x] = Node(nx, ny, 1);
Mx[nx].insert(x);
My[ny].insert(x);
}
}
}
return 0;
}

24
HDOJ/4882_autoAC.cpp Normal file
View File

@ -0,0 +1,24 @@
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 101000
using namespace std;
struct YYC
{
int x,y;
bool operator < (const YYC &a)const
{return x*a.y<y*a.x;}
}fev[N];
int n;
long long ans,sum;
int main()
{
int i;scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",&fev[i].x);
for(i=1;i<=n;i++)scanf("%d",&fev[i].y);
sort(fev+1,fev+n+1);
for(i=1;i<=n;i++)sum+=fev[i].x,ans+=sum*fev[i].y;
cout<<ans<<endl;
return 0;
}

32
HDOJ/4883_autoAC.cpp Normal file
View File

@ -0,0 +1,32 @@
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
int a[2000];
int T,m,i;
scanf("%d",&T);
while(T--)
{
int n,h1,h2,m1,m2;
int sum1,sum2,maxx=0;
scanf("%d",&m);
memset(a,0,sizeof(a));
while(m--)
{
scanf("%d%d:%d%d:%d",&n,&h1,&m1,&h2,&m2);
sum1=h1*60+m1;
sum2=h2*60+m2;
for(i=sum1;i<sum2;i++)
{
a[i]+=n;
maxx=max(maxx,a[i]);
}
}
printf("%d\n",maxx);
}
return 0;
}

41
HDOJ/4884_autoAC.cpp Normal file
View File

@ -0,0 +1,41 @@
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
using namespace std;
const int N = 1010;
const int lim = 24*60;
int T, n, t, k, m;
int cnt[N], last[N];
void print(int time){
if(time>=lim) time%=lim;
printf("%02d:%02d\n", time/60, time%60);
}
int main(){
scanf("%d", &T);
while(T--){
scanf("%d %d %d %d", &n, &t, &k, &m);
memset(cnt,0,sizeof(cnt));
int hh, mm, a, b;
int cur = 0;
for(int i=0; i<m; i++){
scanf("%d:%d %d %d", &hh, &mm, &a, &b);
hh = hh*60+mm;
if(cnt[a]>=b && last[a]>=hh){
cnt[a]-=b;
print(last[a]+t);
continue;
}
if(cnt[a] && last[a]>=hh){
b-=cnt[a];
}
int x = (b-1)/k + 1;
cur = max(cur, hh) + t*x;
print(cur);
cnt[a] = x * k - b;
last[a] = cur - t;
}
if(T) puts("");
}
return 0;
}

130
HDOJ/4885_autoAC.cpp Normal file
View File

@ -0,0 +1,130 @@
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;
#define REP( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define REV( i , a , b ) for ( int i = a - 1 ; i >= b ; -- i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define FOV( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define CLR( a , x ) memset ( a , x , sizeof a )
typedef long long LL ;
const int MAXN = 1005 ;
const int MAXQ = 2000005 ;
const int MAXE = 2000005 ;
const int INF = 0x3f3f3f3f ;
struct Node {
int x , y , idx ;
Node () {}
Node ( int x , int y , int idx ) : x ( x ) , y ( y ) , idx ( idx ) {}
void input ( int __ ) {
scanf ( "%d%d" , &x , &y ) ;
idx = __ ;
}
bool operator < ( const Node &a ) const {
return x != a.x ? x < a.x : y < a.y ;
}
} a[MAXN] ;
struct Edge {
int v , c , n ;
Edge () {}
Edge ( int v , int c , int n ) : v ( v ) , c ( c ) , n ( n ) {}
} ;
Edge E[MAXE] ;
int H[MAXN] , cntE ;
int Q[MAXQ] ;
int head , tail , inq[MAXN] ;
int d[MAXN] ;
int n , L ;
int s , t ;
void init () {
cntE = 0 ;
CLR ( H , -1 ) ;
}
void addedge ( int u , int v , int c ) {
E[cntE] = Edge ( v , c , H[u] ) ;
H[u] = cntE ++ ;
E[cntE] = Edge ( u , c , H[v] ) ;
H[v] = cntE ++ ;
}
LL dist ( int i , int j ) {
LL x = a[i].x - a[j].x ;
LL y = a[i].y - a[j].y ;
return x * x + y * y ;
}
void spfa () {
head = tail = 0 ;
CLR ( inq , 0 ) ;
CLR ( d , INF ) ;
d[s] = 0 ;
Q[tail ++] = s ;
while ( head != tail ) {
int u = Q[head ++] ;
inq[u] = 0 ;
for ( int i = H[u] ; ~i ; i = E[i].n ) {
int v = E[i].v ;
if ( d[v] > d[u] + 1 ) {
d[v] = d[u] + 1 ;
if ( !inq[v] ) {
inq[v] = 1 ;
Q[tail ++] = v ;
}
}
}
}
}
int cha ( int i , int j , int k ) {
LL x1 = a[i].x - a[j].x ;
LL x2 = a[j].x - a[k].x ;
LL y1 = a[i].y - a[j].y ;
LL y2 = a[j].y - a[k].y ;
if ( x1 * y2 - x2 * y1 )
return 1 ;
return 0 ;
}
void build () {
LL LLL = ( LL ) L * L ;
REP ( i , 0 , n )
REP ( j , i + 1 , n )
if ( dist ( i , j ) <= LLL ) {
int ok = 1 ;
int minx = min ( a[i].x , a[j].x ) ;
int maxx = max ( a[i].x , a[j].x ) ;
int miny = min ( a[i].y , a[j].y ) ;
int maxy = max ( a[i].y , a[j].y ) ;
for ( int k = i + 1 ; ok && k < j ; ++ k )
if ( cha ( i , j , k ) == 0 )
ok = 0 ;
if ( ok )
addedge ( i , j , 1 ) ;
}
}
void solve () {
init () ;
int x , y ;
scanf ( "%d%d" , &n , &L ) ;
a[n].input ( n ) ;
a[n + 1].input ( n + 1 ) ;
REP ( i , 0 , n )
a[i].input ( i ) ;
n += 2 ;
sort ( a , a + n ) ;
build () ;
REP ( i , 0 , n ) {
if ( a[i].idx == n - 2 )
s = i ;
if ( a[i].idx == n - 1 )
t = i ;
}
spfa () ;
if ( d[t] == INF )
printf ( "impossible\n" ) ;
else
printf ( "%d\n" , d[t] - 1 ) ;
}
int main () {
int T ;
scanf ( "%d" , &T ) ;
while ( T -- )
solve () ;
return 0 ;
}

71
HDOJ/4886_autoAC.cpp Normal file
View File

@ -0,0 +1,71 @@
#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <vector>
#include <cmath>
#include <cstdlib>
using namespace std;
const int maxn=1e6+10;
char a[maxn];
bool f[6][maxn];
int g[10],p[10];
void init()
{
int i,j,k;
p[0]=1;
for(i=1;i<=6;i++)
p[i]=p[i-1]*8;
}
void print(int a,int b)
{
int i,j,k,ans[10];
for(i=0;i<a;i++)
{
ans[i]=b%8;
b=b/8;
}
for(i=a-1;i>=0;i--)
printf("%c",ans[i]+'A');
printf("\n");
}
int main()
{
init();
int T;
scanf("%d",&T);
while(T--)
{
int i,j,k,n;
memset(f,false,sizeof(f));
memset(g,0,sizeof(g));
scanf("%s",a);
n=strlen(a);
for(i=0;i<n;i++)
{
for(j=1;j<=6;j++)
{
g[j]=g[j]*8+(a[i]-'A');
if(i>=j)
{
g[j]-=(a[i-j]-'A')*p[j];
f[j-1][g[j]]=true;
}
else if(i==j-1)
{
f[j-1][g[j]]=true;
}
}
}
for(i=0;i<6;i++)
{
for(j=0;j<p[i+1];j++)
if(!f[i][j])break;
if(j<p[i+1])break;
}
print(i+1,j);
}
return 0;
}

203
HDOJ/4887_autoAC.cpp Normal file
View File

@ -0,0 +1,203 @@
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
using namespace std;
#define ll __int64
#define usint unsigned int
const usint NONE=0xffffffff;
int n,s1,s2;
int a1[33],a2[33];
usint xo;
class hash {
public:
hash() {
memset(a,0xff,sizeof(a));
}
usint locate(usint x) {
usint l=x%MOD;
while(a[l]!=x&&a[l]!=NONE) l=l+1;
return l;
}
void insert(usint x,usint va) {
usint l=locate(x);
if(a[l]==NONE) {
a[l]=x;
v[l]=va;
}
}
usint get(usint x) {
usint l=locate(x);
return a[l]==x?v[l]:NONE;
}
void clear() {
memset(a,0xff,sizeof(a));
}
private:
static const usint MOD=1000007;
usint a[MOD+100],v[MOD+100];
} S;
struct vct {
bool a[33];
vct(bool q[33]) {
for(int i=0; i<=n; i++)
a[i]=q[i];
}
vct() {}
void clear() {
memset(a,0,sizeof(a));
}
void show() {
for(int i=0; i<=n; i++)
printf("%d ",a[i]);
puts("");
}
};
struct matrix {
bool a[33][33];
matrix(bool q[33][33]) {
for(int i=0; i<=n; i++)
for(int j=0; j<=n; j++)
a[i][j]=q[i][j];
}
matrix() {}
void clear() {
memset(a,0,sizeof(a));
}
friend matrix operator *(matrix A,matrix B) {
matrix re;
int i,j,k;
re.clear();
for(i=0; i<=n; i++)
for(j=0; j<=n; j++)
for(k=0; k<=n; k++)
re.a[i][j]=(re.a[i][j]^(A.a[i][k]*B.a[k][j]));
return re;
}
void danwei() {
memset(a,0,sizeof(a));
for(int i=0; i<=n; i++)
a[i][i]=1;
}
void show() {
for(int i=0; i<=n; i++) {
for(int j=0; j<=n; j++)
printf("%d ",a[i][j]);
puts("");
}
}
};
inline usint atox(bool a[33],int n) {
usint re=0;
for(int i=0; i<n; i++)
re=(re<<1)+a[n-i-1];
return re;
}
inline int xtoa(bool a[33],int n,usint x) {
for(int i=0; i<n; i++) {
a[i]=x&1;
x=x>>1;
}
}
void check(bool a[33],int n) {
for(int i=0; i<n; i++)
printf("%2d",a[i]);
puts("");
}
inline usint next(usint now) {
bool a[33],j;
usint re;
xtoa(a,n,now);
j=a[a1[0]];
for(int i=1; i<s1; i++)
j^=a[a1[i]];
re=(now>>1)+(j<<(n-1));
re^=xo;
return re;
}
vct operator * (matrix mt,vct v) {
vct re;
int i,j;
re.clear();
for(i=0; i<=n; i++)
for(j=0; j<=n; j++)
re.a[i]=(re.a[i]^(mt.a[i][j]*v.a[j]));
return re;
}
matrix qpow(matrix a,usint x) {
matrix re,t;
re.danwei();
t=a;
while(x>0) {
if(x&1==1)re=re*t;
x=x>>1;
t=t*t;
}
return re;
}
int main() {
usint i,j;
bool a[33];
usint cnt;
usint st,ed,now,m,t;
matrix ni,nc,n1,n2;
vct v;
while(scanf("%d%d%d",&n,&s1,&s2)!=EOF) {
for(i=0; i<s1; i++) {
scanf("%d",&a1[i]);
a1[i]--;
}
xo=0;
for(i=0; i<s2; i++) {
scanf("%d",&j);
a2[i]=j-1;
xo=xo|(1<<(j-1));
}
for(i=0; i<n; i++)
scanf("%d",&a[i]);
st=atox(a,n);
for(i=0; i<n; i++)
scanf("%d",&a[i]);
ed=atox(a,n);
n1.clear();
n2.clear();
for(i=0; i<=n; i++)
n2.a[i][i]=1;
for(i=0; i<s2; i++)
n2.a[a2[i]][n]=1;
for(i=0; i<s1; i++)
if(a1[i]>0) n1.a[0][a1[i]-1]=1;
n1.a[0][n-1]=1;
for(i=0; i<n-1; i++)
n1.a[i+1][i]=1;
n1.a[n][n]=1;
ni=n1*n2;
now=st;
S.clear();
m=ceil(sqrt(((usint)1)<<n));
for(i=0; i<m; i++) {
S.insert(now,i);
now=next(now);
}
nc=qpow(ni,m);
now=ed;
cnt=0;
t=S.get(now);
while(t==NONE) {
if(cnt>m) break;
xtoa(v.a,n,now);
v.a[n]=1;
v=nc*v;
now=atox(v.a,n);
cnt++;
t=S.get(now);
}
if(t==NONE) printf("poor sisyphus\n");
else printf("%u\n",cnt*m+t);
}
return 0;
}

152
HDOJ/4888_autoAC.cpp Normal file
View File

@ -0,0 +1,152 @@
#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 S,T ;
int vis[100005] ;
int JG(int u,int fa)
{
if(vis[u])return 1 ;
vis[u]=1 ;
for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
{
int v=e[i].t ;
if(v!=fa && v!=S && v!=T && e[i].cap)
if(JG(v,u))return 1 ;
}
vis[u]=0 ;
return 0 ;
}
int A[505],B[505] ;
int res[505][505] ;
int main()
{
int k ;
while(~scanf("%d%d%d",&n,&m,&k))
{
cnt=0 ;
memset(head,-1,sizeof(head)) ;
int sum1=0,sum2=0 ;
S=0 ;T=n+m+1 ;
for(int i=1 ;i<=n ;i++)
{
scanf("%d",&A[i]) ;
sum1+=A[i] ;
add(S,i,A[i]) ;
for(int j=1 ;j<=m ;j++)
add(i,j+n,k) ;
}
for(int i=1 ;i<=m ;i++)
{
scanf("%d",&B[i]) ;
sum2+=B[i] ;
add(i+n,T,B[i]) ;
}
int ans=dinic(S,T) ;
if(ans==sum1 && ans==sum2)
{
int flag=0 ;
memset(vis,0,sizeof(vis)) ;
for(int i=1 ;i<=n ;i++)
{
if(JG(i,-1))
{
flag=1 ;
break ;
}
}
if(flag)
{
puts("Not Unique") ;
}
else
{
puts("Unique") ;
memset(res,0,sizeof(res)) ;
for(int i=1 ;i<=n ;i++)
{
for(int j=head[i] ;j!=-1 ;j=e[j].nxt)
{
if(e[j].t<=n+m && e[j].t>n)
res[i][e[j].t-n]=k-e[j].cap ;
}
}
for(int i=1 ;i<=n ;i++)
{
for(int j=1 ;j<=m ;j++)
{
if(j>1)printf(" ") ;
printf("%d",res[i][j]) ;
}
putchar('\n') ;
}
}
}
else
{
puts("Impossible") ;
}
}
return 0 ;
}

21
HDOJ/4889_autoAC.cpp Normal file
View File

@ -0,0 +1,21 @@
#include<iostream>
#include<cstdio>
using namespace std;
const int T = 30;
int main()
{
int c;
while (scanf("%d",&c)!=EOF)
{
int n , m , i ;
n = T * 2 + 1;
m = T * 3;
printf("%d %d\n",n,m);
for (int i = 0 ; i <T ; i ++)
printf("%d %d %d\n",i * 2 + 1 , i * 2 + 2 , 0);
for (int i = 0 ; i <T ; i ++)
printf("%d %d %d\n",i * 2 + 2 , i * 2 + 3 , - ( 1 << T - i ));
for (int i = 0 ; i <T ; i ++)
printf("%d %d %d\n",i * 2 + 1 , i * 2 + 3 , -( 1 << T - i - 1 ));
}
}

206
HDOJ/4890_autoAC.cpp Normal file
View File

@ -0,0 +1,206 @@
#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
struct node {
int a[35][35];
int n, m;
void rota() {
int b[35][35];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
b[j][n - i - 1] = a[i][j];
}
}
swap(n, m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
a[i][j] = b[i][j];
}
} p[4], s;
int a[35][35];
int n, m;
int ans;
node cur[5];
void gao(int now) {
if (now == 4) {
for (int i = 0; i < 3; ++i)
if (cur[i].n != cur[i + 1].n || cur[i].m != cur[i + 1].m)
return;
int minn = 100000;
for (int i = 0; i < cur[0].n; ++i) {
for (int j = 0; j < cur[0].m; ++j) {
int sum = 0;
for (int k = 0; k < 4; ++k) {
sum += cur[k].a[i][j];
}
if (sum < minn)
minn = sum;
}
}
if (minn > ans)
ans = minn;
return;
}
cur[now] = p[now];
gao(now + 1);
for (int i = 0; i < 4; ++i) {
cur[now].rota();
gao(now + 1);
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
scanf("%d", &a[i][j]);
ans = 0;
if (n % 4 == 0) {
for (int i = 0; i < 4; ++i) {
for (int j = n / 4 * i; j < n / 4 * (i + 1); ++j) {
for (int k = 0; k < m; ++k) {
p[i].a[j % (n / 4)][k] = a[j][k];
}
}
p[i].n = n / 4;
p[i].m = m;
}
gao(0);
}
if (m % 4 == 0) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = i * (m / 4); k < (i + 1) * m / 4; ++k) {
p[i].a[j][k % (m / 4)] = a[j][k];
}
}
p[i].n = n;
p[i].m = m / 4;
}
gao(0);
}
if (n % 2 == 0 && m % 2 == 0) {
for (int i = 0; i < 4; ++i) {
for (int j = (i / 2) * n / 2; j < (i / 2 + 1) * n / 2; ++j) {
for (int k = (i % 2) * m / 2; k < (i % 2 + 1) * m / 2;
++k) {
p[i].a[j % (n / 2)][k % (m / 2)] = a[j][k];
}
}
p[i].n = n / 2;
p[i].m = m / 2;
}
gao(0);
}
s.n = n;
s.m = m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
s.a[i][j] = a[i][j];
if (n < m) {
s.rota();
swap(n, m);
}
if (3 * s.n == 4 * s.m && s.m % 3 == 0 && s.n % 4 == 0) {
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < m; ++j) {
for (int k = i * m / 3; k < (i + 1) * m / 3; ++k) {
p[i].a[j][k % (m / 3)] = s.a[j][k];
}
}
p[i].n = m;
p[i].m = m / 3;
}
for (int i = m; i < n; ++i)
for (int j = 0; j < m; ++j)
p[3].a[i - m][j] = s.a[i][j];
p[3].n = n - m;
p[3].m = m;
gao(0);
for (int i = 0; i < 3; ++i) {
for (int j = n - m; j < n; ++j) {
for (int k = i * m / 3; k < (i + 1) * m / 3; ++k) {
p[i].a[j - (n - m)][k % (m / 3)] = s.a[j][k];
}
}
p[i].n = m;
p[i].m = m / 3;
}
for (int i = 0; i < n - m; ++i)
for (int j = 0; j < m; ++j)
p[3].a[i][j] = s.a[i][j];
p[3].n = n - m;
p[3].m = m;
gao(0);
}
if (s.n == 2 * s.m && s.m % 2 == 0) {
for (int i = 0; i < n / 2; ++i)
for (int j = 0; j < m / 2; ++j)
p[0].a[i][j] = s.a[i][j];
p[0].n = s.n / 2;
p[0].m = s.m / 2;
for (int i = 0; i < n / 2; ++i)
for (int j = m / 2; j < m; ++j)
p[1].a[i][j - m / 2] = s.a[i][j];
p[1].n = s.n / 2;
p[1].m = s.m / 2;
for (int i = n / 2; i < n / 4 * 3; ++i)
for (int j = 0; j < m; ++j)
p[2].a[i - n / 2][j] = s.a[i][j];
p[2].n = s.n / 4;
p[2].m = s.m;
for (int i = n / 4 * 3; i < n; ++i)
for (int j = 0; j < m; ++j)
p[3].a[i - n / 4 * 3][j] = s.a[i][j];
p[3].n = n / 4;
p[3].m = m;
gao(0);
for (int i = n / 4; i < n / 4 * 3; ++i)
for (int j = 0; j < m / 2; ++j)
p[0].a[i - n / 4][j] = s.a[i][j];
p[0].n = s.n / 2;
p[0].m = s.m / 2;
for (int i = n / 4; i < n / 4 * 3; ++i)
for (int j = m / 2; j < m; ++j)
p[1].a[i - n / 4][j - m / 2] = s.a[i][j];
p[1].n = s.n / 2;
p[1].m = s.m / 2;
for (int i = 0; i < n / 4; ++i)
for (int j = 0; j < m; ++j)
p[2].a[i][j] = s.a[i][j];
p[2].n = s.n / 4;
p[2].m = s.m;
for (int i = n / 4 * 3; i < n; ++i)
for (int j = 0; j < m; ++j)
p[3].a[i - n / 4 * 3][j] = s.a[i][j];
p[3].n = n / 4;
p[3].m = m;
gao(0);
for (int i = n / 2; i < n; ++i)
for (int j = 0; j < m / 2; ++j)
p[0].a[i - n / 2][j] = s.a[i][j];
p[0].n = s.n / 2;
p[0].m = s.m / 2;
for (int i = n / 2; i < n; ++i)
for (int j = m / 2; j < m; ++j)
p[1].a[i - n / 2][j - m / 2] = s.a[i][j];
p[1].n = s.n / 2;
p[1].m = s.m / 2;
for (int i = 0; i < n / 4; ++i)
for (int j = 0; j < m; ++j)
p[2].a[i][j] = s.a[i][j];
p[2].n = s.n / 4;
p[2].m = s.m;
for (int i = n / 4; i < n / 2; ++i)
for (int j = 0; j < m; ++j)
p[3].a[i - n / 4][j] = s.a[i][j];
p[3].n = n / 4;
p[3].m = m;
gao(0);
}
printf("%d\n", ans);
}
return 0;
}

63
HDOJ/4891_autoAC.cpp Normal file
View File

@ -0,0 +1,63 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
char str[5000000],s[5000000];
int main()
{
int n,i,j;
int cnt1,cnt2,flag1,flag2,len;
__int64 sum;
while(scanf("%d",&n)!=EOF)
{
gets(str);
len = 0;
for(i = 0; i<n; i++)
{
gets(str);
int l = strlen(str);
for(j = 0; j<l; j++)
{
s[len] = str[j];
len++;
}
}
flag1 = flag2 = cnt1 = cnt2 = 0;
sum = 1;
for(i = 0; i<len; i++)
{
if(s[i] == '{')
flag1 = 1;
else if(flag1 && s[i] == '|')
cnt1++;
else if(flag1 && s[i] == '}')
{
flag1 = 0;
sum*=(cnt1+1);
cnt1 = 0;
}
else if(s[i] == '$' && flag2 == 0)
flag2 = 1;
else if(s[i] == '$' && flag2 == 1)
{
sum = sum*(cnt2+1);
cnt2 = 0;
flag2 = 0;
}
else if(flag2 && s[i] == ' ')
cnt2++;
else if(flag2 && s[i] != ' ' && s[i]!='$')
{
sum = sum*(cnt2+1);
cnt2 = 0;
}
if(sum>100000)
break;
}
if(sum>100000)
printf("doge\n");
else
printf("%I64d\n",sum);
}
return 0;
}

174
HDOJ/4892_autoAC.cpp Normal file
View File

@ -0,0 +1,174 @@
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define prt(k) cout<<#k" = "<<k<<endl
#include <cmath>
#include <algorithm>
const int N = 333;
const int M = 41;
const int MAXN = 12111;
int sqr(int x) { return x * x; }
struct P
{
double x, y; int t;
P() {}
P(double _x, double _y) { x=_x, y=_y; }
double dis(P b)
{
return sqrt((x-b.x)*(x-b.x)+(y-b.y)*(y-b.y));
}
double operator * (P b)
{
return x*b.y - y*b.x;
}
P operator - (P b) { return P(x-b.x,y-b.y); }
}p[454];
double dis(P a, P b) { return a.dis(b); }
int n, m, kind;
P a[334], b[545];
const double inf = 1e18;
const double eps = 1e-8;
double cross(P a, P b) { return a * b; }
double cross(P a, P b, P c) { return (b - a) * (c - a); }
int cmp(double x) { return x < -eps ? -1 : x > eps; }
bool in(P p, P a, P b, P c)
{
double t = fabs(cross(p,a,b)) + fabs(cross(p,b,c)) + fabs(cross(p,a,c));
return cmp(t - fabs(cross(a,b,c))) == 0;
}
int side(P a, P b, P s, P t)
{
return cmp(cross(s,a,t) * cross(s,b,t));
}
int mask[MAXN];
int id[M][M][M];
int getID(int i, int j, int k)
{
int a[3];
a[0] = i, a[1] = j, a[2] = k;
sort(a, a+3);
return id[a[0]][a[1]][a[2]];
}
double w[M][M];
const int E = 1012000;
int to[E], ne[E]; double cost[E];
int head[MAXN];
int tot;
void initEdge()
{
tot = 0;
memset(head, -1, sizeof head);
}
void addEdge(int u, int v, double w)
{
to[tot] = v, cost[tot] = w;
ne[tot] = head[u];
head[u] = tot++;
}
double d[66][MAXN];
#include <queue>
int cnt;
bool inq[MAXN];
void spfa(double d[], int n)
{
queue<int> q;
for(int i=0;i<n;i++) inq[i] = true, q.push(i);
while(!q.empty())
{
int u=q.front(); q.pop(); inq[u] = false;
for(int i=head[u];~i;i=ne[i])
{
int v = to[i];
if(d[v] > d[u] + cost[i] + eps)
{
d[v] = d[u] + cost[i];
if(!inq[v])
{
inq[v] = true;
q.push(v);
}
}
}
}
}
double solve()
{
memset(inq, 0, sizeof inq);
for(int S=0;S<(1<<kind);S++)
{
spfa(d[S], cnt);
for(int u=0;u<cnt;u++)
{
for(int e=head[u];~e;e=ne[e])
{
int v = to[e];
d[S|mask[v]][v] = min(d[S|mask[v]][v], d[S][u] + cost[e]);
}
}
}
double ans = inf;
for(int i=0;i<cnt;i++) ans = min(ans, d[(1<<kind)-1][i]);
return ans;
}
int main()
{
while(scanf("%d%d%d", &n, &m, &kind)==3)
{
initEdge();
for(int i=0;i<n;i++) scanf("%lf%lf", &a[i].x, &a[i].y);
for(int i=0;i<n;i++) scanf("%d", &a[i].t), a[i].t--;
for(int i=0;i<m;i++) scanf("%lf%lf", &b[i].x, &b[i].y), p[i] = b[i];
cnt = 0;
memset(mask, 0, sizeof mask);
for(int i=0;i<m;i++)
{
w[i][i] = 0;
for(int j=i+1;j<m;j++)
w[i][j] = w[j][i] = dis(p[i], p[j]);
}
for(int i=0;i<m;i++)
{
for(int j=i+1;j<m;j++)
{
for(int k=j+1;k<m;k++)
{
mask[cnt] = 0;
for(int t = 0; t < n; t++)
{
int id = a[t].t;
if(in(a[t], b[i],b[j],b[k]))
{
mask[cnt] |= (1<<id);
}
}
for(int t=0;t<(1<<kind);t++) d[t][cnt] = inf;
d[mask[cnt]][cnt] = w[i][j] + w[j][k] + w[i][k];
id[i][j][k] = cnt++;
}
}
}
for(int i=0;i<m;i++)
{
for(int j=i+1;j<m;j++)
{
for(int k=0;k<m;k++)
{
for(int t=k+1;t<m;t++)
{
if(k==i||k==j||t==i|t==j) continue;
if(side(p[k], p[t], p[i], p[j]) != -1) continue;
int u = getID(i, j, k);
int v = getID(i, j, t);
addEdge(u, v, w[i][t] + w[t][j] - w[i][j]);
addEdge(v, u, w[i][k] + w[k][j] - w[i][j]);
}
}
}
}
double ans = solve();
if(cmp(ans - inf) >= 0) printf("Impossible\n");
else printf("%.12f\n", ans);
}
return 0;
}

141
HDOJ/4893_autoAC.cpp Normal file
View File

@ -0,0 +1,141 @@
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define ll __int64
#define maxn 100005
#define ls l,mid,2*i
#define rs mid+1,r,2*i+1
#define lson 2*i
#define rson 2*i+1
struct node
{
int l,r;
ll e,f;
int flag,len;
} a[maxn<<2];
int n,m;
ll f[90] = {1,1};
ll pabs(ll a)
{
return a<0?-a:a;
}
void PushDown(int i,int m)
{
if(a[i].flag)
{
a[lson].flag = a[rson].flag = a[i].flag;
a[lson].len = a[i].flag*(m-m>>1);
a[rson].len = a[i].flag*(m>>1);
a[lson].e = a[lson].f;
a[rson].e = a[rson].f;
a[i].flag = 0;
}
}
void PushUp(int i)
{
a[i].e = a[lson].e+a[rson].e;
a[i].f = a[lson].f+a[rson].f;
}
void init(int l,int r,int i)
{
a[i].flag = a[i].len = 0;
a[i].l = l;
a[i].r = r;
a[i].e = 0;
if(l == r)
{
a[i].f = 1;
return;
}
int mid = (l+r)>>1;
init(ls);
init(rs);
PushUp(i);
}
void add(int pos,int m,int l,int r,int i)
{
if(pos<l || pos>r) return ;
if(l == r)
{
if(a[i].flag)
{
a[i].e = m+a[i].f;
a[i].flag = 0;
a[i].len = 0;
}
else a[i].e+=m;
int p = lower_bound(f,f+80,a[i].e)-f;
if(!p)
a[i].f = 1;
else if(pabs(a[i].e-f[p])<pabs(a[i].e-f[p-1]))
a[i].f = f[p];
else
a[i].f = f[p-1];
return ;
}
PushDown(i,r-l+1);
int mid = (l+r)>>1;
if(pos<=mid) add(pos,m,ls);
else add(pos,m,rs);
PushUp(i);
}
ll query(int L,int R,int l,int r,int i)
{
if(R<l || L>r) return 0;
else if(L<=l && R>=r) return a[i].e;
PushDown(i,r-l+1);
ll ans = 0;
int mid = (l+r)>>1;
if(L<=mid)
ans += query(L,R,ls);
if(R>mid)
ans += query(L,R,rs);
return ans;
}
void change(int L,int R,int l,int r,int i)
{
if(R<l || L>r) return ;
if(L<=l && R>=r)
{
a[i].e = a[i].f;
a[i].flag = 1;
a[i].len = r-l+1;
return ;
}
PushDown(i,r-l+1);
int mid = (l+r)>>1;
if(L<=mid)
change(L,R,ls);
if(R>mid)
change(L,R,rs);
PushUp(i);
}
int main()
{
int i,j,x,k,d,l,r;
for(i = 2; i<80; i++)
f[i] = f[i-1]+f[i-2];
while(~scanf("%d%d",&n,&m))
{
init(1,n,1);
while(m--)
{
scanf("%d",&x);
if(x == 1)
{
scanf("%d%d",&k,&d);
add(k,d,1,n,1);
}
else
{
scanf("%d%d",&l,&r);
if(x == 2)
printf("%I64d\n",query(l,r,1,n,1));
else
change(l,r,1,n,1);
}
}
}
return 0;
}

86
HDOJ/4896_autoAC.cpp Normal file
View File

@ -0,0 +1,86 @@
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#define eps 1e-9
#define LL long long
#define mod 2333333
using namespace std;
map <int , int> ma;
int pos[100];
int clo,p,ed;
struct node
{
int x,y,w;
}a[250000];
int f[500];
LL te[200];
int cmp(node a,node b)
{
return (a.w<b.w);
}
int getf(int x)
{
if (x==f[x]) return x;
else return (f[x]=getf(f[x]));
}
int unite(int x,int y)
{
if (getf(x)!=getf(y)) f[getf(x)]=getf(y);
}
LL kru()
{
LL ans=0;
for (int i=1;i<=ed;i++)
if (getf(a[i].x)!=getf(a[i].y)) {
ans+=a[i].w;
unite(a[i].x,a[i].y);
}
return ans;
}
int main()
{
LL n,seed;
while (~scanf("%I64d%I64d",&n,&seed))
{
ma.clear();
int cur=seed;
int t=0;
while (ma[cur]==0)
{
t++;
pos[t]=cur;
pos[0]=cur;
ma[cur]=1;
cur=cur*907%mod;
}
for (int k=1;k<=108;k++)
{
for (int i=1;i<=k;i++)
f[i]=i;
clo=ed=0;
for (int i=1;i<=k;i++)
{
clo++;
clo%=54;
p=pos[clo];
for (int j=max(1,i-5);j<i;j++)
{
clo++;
clo%=54;
ed++;
a[ed].x=i;
a[ed].y=j;
a[ed].w=pos[clo]^p;
}
}
sort(a+1,a+1+ed,cmp);
te[k]=kru();
}
if (n<=108) printf("%I64d\n",te[n]);
else printf("%I64d\n",te[54+n%54]+(n/54-1)*(te[108]-te[54]));
}
return 0;
}

183
HDOJ/4897_autoAC.cpp Normal file
View File

@ -0,0 +1,183 @@
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define ls (p<<1)
#define rs (p<<1|1)
#define NN 201000
int en[NN],fi[NN],te,ne[NN],v[NN];
int tp;
int siz[NN],son[NN],top[NN],fa[NN],dep[NN],tid[NN],ran[NN];
void addedge(int a,int b){
++te;ne[te]=fi[a];fi[a]=te;v[te]=b;
++te;ne[te]=fi[b];fi[b]=te;v[te]=a;
}
void dfs1(int u,int father,int d){
siz[u]=1;
dep[u]=d;
fa[u]=father;
int e,vv;
for(e=fi[u];e!=-1;e=ne[e]){
vv=v[e];
if (vv!=father){
dfs1(vv,u,d+1);
siz[u]+=siz[vv];
if (son[u]==-1||siz[vv]>siz[son[u]]){
son[u]=vv;
}
}
}
}
void dfs2(int u,int ttop){
top[u]=ttop;
tid[u]=++tp;
ran[tid[u]]=u;
if (son[u]==-1) return;
dfs2(son[u],ttop);
int e,vv;
for(e=fi[u];e!=-1;e=ne[e]){
vv=v[e];
if (vv!=fa[u]&&vv!=son[u]){
dfs2(vv,vv);
}
}
}
struct segtree{
int l,r,tag1,tag2,rev1,rev2;
}t[NN*4];
inline void Rev(int p,int func){
if (func==1) {t[p].rev1^=1;t[p].tag1=t[p].r+1-t[p].l-t[p].tag1;}
if (func==2) {t[p].rev2^=1;t[p].tag2^=1;}
}
void lazy(int p){
if (t[p].l==t[p].r) {t[p].rev1=t[p].rev2=0;return;}
if (t[p].rev1!=0) {
t[p].rev1=0;
Rev(ls,1);
Rev(rs,1);
}
if (t[p].rev2!=0) {
t[p].rev2=0;
Rev(ls,2);
Rev(rs,2);
}
}
void build(int l,int r,int p){
t[p].l=l;t[p].r=r;
t[p].tag1=t[p].tag2=t[p].rev1=t[p].rev2=0;
if (l==r){return;}
int m=l+r>>1;
build(l,m,ls);
build(m+1,r,rs);
}
inline void update(int p){
t[p].tag1=t[ls].tag1+t[rs].tag1;
}
void rev(int l,int r,int func,int p){
if (l>r) return;
if (t[p].l==l&&t[p].r==r){
Rev(p,func);
return;
}
lazy(p);
int m=t[p].l+t[p].r>>1;
if (r<=m) rev(l,r,func,ls);
else if (l>m) rev(l,r,func,rs);
else {
rev(l,m,func,ls);
rev(m+1,r,func,rs);
}
update(p);
}
int query(int l,int r,int p){
if (l>r) return 0;
if (t[p].l==l&&t[p].r==r){
return t[p].tag1;
}
lazy(p);
int m=t[p].l+t[p].r>>1;
if (r<=m) return query(l,r,ls);
else if (l>m) return query(l,r,rs);
else {
return query(l,m,ls)+query(m+1,r,rs);
}
update(p);
}
int querytag2(int pos,int p){
if (t[p].l==t[p].r) return t[p].tag2;
lazy(p);
int m=t[p].l+t[p].r>>1;
if (pos<=m) return querytag2(pos,ls);
else return querytag2(pos,rs);
update(p);
}
void linerev(int a,int b){
while(top[a]!=top[b]){
if (dep[top[a]]<dep[top[b]]) swap(a,b);
rev(tid[top[a]],tid[a],1,1);
a=fa[top[a]];
}
if (dep[a]>dep[b]) swap(a,b);
rev(tid[a]+1,tid[b],1,1);
}
void linerevadj(int a,int b){
while(top[a]!=top[b]){
if (dep[top[a]]<dep[top[b]]) swap(a,b);
rev(tid[top[a]],tid[a],2,1);
int faa=fa[top[a]];
if (son[faa]==top[a]) rev(tid[top[a]],tid[top[a]],1,1);
if (son[a]!=-1) rev(tid[son[a]],tid[son[a]],1,1);
a=fa[top[a]];
}
if (dep[a]>dep[b]) swap(a,b);
rev(tid[a],tid[b],2,1);
int faa=fa[a];
if (faa!=0&&son[faa]==a) rev(tid[a],tid[a],1,1);
if (son[b]!=-1) rev(tid[son[b]],tid[son[b]],1,1);
}
int linequery(int a,int b){
int ret=0;
while(top[a]!=top[b]){
if (dep[top[a]]<dep[top[b]]) swap(a,b);
ret+=query(tid[top[a]]+1,tid[a],1);
ret+=(querytag2(tid[fa[top[a]]],1)^querytag2(tid[top[a]],1)^query(tid[top[a]],tid[top[a]],1));
a=fa[top[a]];
}
if (dep[a]>dep[b]) swap(a,b);
ret+=query(tid[a]+1,tid[b],1);
return ret;
}
int main(){
int cas,n,q,i,a,b,c;
scanf("%d",&cas);
while(cas--){
scanf("%d",&n);
memset(fi,-1,sizeof(fi));
te=0;
for(i=1;i<n;++i){
scanf("%d%d",&a,&b);
addedge(a,b);
}
memset(son,-1,sizeof(son));
tp=0;
dfs1(1,0,0);
dfs2(1,1);
build(1,tp,1);
scanf("%d",&q);
for(i=1;i<=q;++i){
scanf("%d%d%d",&a,&b,&c);
if (a==1){
if (b==c) continue;
linerev(b,c);
}
else if (a==2){
linerevadj(b,c);
}
else if (a==3){
printf("%d\n",linequery(b,c));
}
}
}
return 0;
}

127
HDOJ/4898_autoAC.cpp Normal file
View File

@ -0,0 +1,127 @@
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define NN 4100
char s[NN];
int n,k;
int tsub;
int lcp[NN][NN];
struct Sub{
int l,r;
void init(int _l,int _r){l=_l;r=_r;}
int size() {return r-l+1;}
char charat(int x) {
if (x>r-l) return 0;
else return s[l+x];
}
}sub[NN*NN];
int Lcp(Sub a,Sub b){
return min(lcp[a.l][b.l],min(a.size(),b.size()));
}
bool operator < (Sub a,Sub b){
int m=Lcp(a,b);
return a.charat(m)<b.charat(m);
}
int step[NN];
bool check(Sub M) {
vector<int> nxt(n);
for (int i = 0; i < n; ++i) {
Sub tmp;
tmp.init(i,i+n-1);
int L = Lcp(tmp, M);
if (s[(i + L) % n] < M.charat(L))
nxt[i] = n;
else
nxt[i] = L;
}
for (;;) {
bool done = true;
for (int i = 0; i < nxt.size(); ++i) {
if (nxt[i] == 0) {
for (int j = 0; j < nxt.size(); ++j)
if (j != i) {
if (j < i && j + nxt[j] >= i)
--nxt[j];
else if (j > i && j + nxt[j] >= i + nxt.size())
--nxt[j];
}
nxt.erase(nxt.begin() + i);
done = false;
break;
}
}
if (done)
break;
}
if (k > nxt.size())
return false;
for (int i = 0; i < nxt.size() * 2; ++i) {
step[i] = i + nxt[i % nxt.size()];
}
for (int i = 0; i < nxt.size(); ++i) {
int need = 0, at = i;
while (at < i + nxt.size()) {
at = step[at];
++need;
}
if (need <= k)
return true;
}
return false;
}
Sub work(){
int l=1,r=tsub,m,ans=r;
int i,j,tot;
while(l<r){
m=l+r>>1;
Sub a=sub[m];
if (check(a)) {
if (ans>m) ans=m;
r=m-1;
}
else l=m+1;
}
return sub[ans];
}
void output(Sub a){
int i,r=a.r;
for(i=a.l;i<=a.r;++i){
printf("%c",s[i]);
}
printf("\n");
}
int main(){
int cas;
scanf("%d",&cas);
int i,j;
while(cas--){
scanf("%d%d",&n,&k);
scanf("%s",s);
for(i=0;i<n;++i){
s[n+i]=s[i];
}
memset(lcp,0,sizeof(lcp));
for(i=n+n-1;i>=0;--i){
for(j=n+n-1;j>=0;--j){
if (s[i]==s[j]) lcp[i][j]=lcp[i+1][j+1]+1;
else lcp[i][j]=0;
}
}
tsub=0;
Sub tmp;
for(i=0;i<n+n;++i){
for(j=i;j<n+n;++j){
if (j-i+1>n) break;
tmp.init(i,j);
sub[++tsub]=tmp;
}
}
sort(sub+1,sub+tsub+1);
tmp=work();
output(tmp);
}
return 0;
}

101
HDOJ/4899_autoAC.cpp Normal file
View File

@ -0,0 +1,101 @@
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<math.h>
#include<limits.h>
#include<time.h>
#include<stdlib.h>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#define LL long long
using namespace std;
const int mod = 1e9 + 7;
char dna[5] = "ATGC";
LL dp[2][70000], prt[20];
int res[20], res1[20], ans[70000][5];
int main()
{
int T;
while(~scanf("%d", &T))
while(T--)
{
memset(res, 0, sizeof res);
memset(ans, 0, sizeof ans);
memset(dp, 0, sizeof dp);
string s;
cin >> s;
int n;
cin >> n;
int len = s.size();
int maxx = 1 << len;
for(int i = 0; i < maxx; i++)
{
res[0] = 0;
int tmp = i;
int cnt = 1;
for(int j = 0; j < len; j++)
{
if(tmp & 1)
res[cnt] = res[cnt - 1] + 1;
else
res[cnt] = res[cnt - 1];
cnt++;
tmp >>= 1;
}
for(int j = 0; j < 4; j++)
{
res1[0] = 0;
for(int k = 1; k <= len; k++)
{
if(s[k - 1] == dna[j])
res1[k] = res[k - 1] + 1;
else
res1[k] = max(res1[k - 1], res[k]);
}
for(int k = len; k > 0; k--)
{
ans[i][j] <<= 1;
if(res1[k] > res1[k - 1])
ans[i][j] += 1;
}
}
}
dp[0][0] = 1;
for(int i = 0; i < n; i++)
{
memset(dp[(i + 1) & 1], 0, sizeof dp[(i + 1) & 1]);
for(int j = 0; j < maxx; j++)
{
for(int k = 0; k < 4; k++)
{
dp[(i + 1) & 1][ans[j][k]] += dp[i & 1][j];
if(dp[(i + 1) & 1][ans[j][k]] > mod)
dp[(i + 1) & 1][ans[j][k]] %= mod;
}
}
}
memset(prt, 0, sizeof prt);
for(int i = 0; i < maxx; i++)
{
int cnt = 0;
int tmp = i;
while(tmp)
{
if(tmp & 1)
cnt++;
tmp >>= 1;
}
prt[cnt] += dp[n & 1][i];
if(prt[cnt] > mod)
prt[cnt] %= mod;
}
for(int i = 0; i <= len; i++)
printf("%lld\n", prt[i]);
}
return 0;
}