From 1b77522684669f1ec4685becd86cdd3cbd3acd17 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Sat, 10 Sep 2016 11:32:44 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 4800-4899 --- HDOJ/4800_autoAC.cpp | 62 ++++++++++ HDOJ/4801_autoAC.cpp | 49 ++++++++ HDOJ/4802_autoAC.cpp | 33 +++++ HDOJ/4803_autoAC.cpp | 59 +++++++++ HDOJ/4804_autoAC.cpp | 49 ++++++++ HDOJ/4805_autoAC.cpp | 174 +++++++++++++++++++++++++++ HDOJ/4807_autoAC.cpp | 93 +++++++++++++++ HDOJ/4808_autoAC.cpp | 17 +++ HDOJ/4809_autoAC.cpp | 91 ++++++++++++++ HDOJ/4810_autoAC.cpp | 63 ++++++++++ HDOJ/4811_autoAC.cpp | 60 ++++++++++ HDOJ/4812_autoAC.cpp | 110 +++++++++++++++++ HDOJ/4813_autoAC.cpp | 20 ++++ HDOJ/4814_autoAC.cpp | 93 +++++++++++++++ HDOJ/4815_autoAC.cpp | 37 ++++++ HDOJ/4816_autoAC.cpp | 111 +++++++++++++++++ HDOJ/4818_autoAC.cpp | 124 +++++++++++++++++++ HDOJ/4819_autoAC.cpp | 150 +++++++++++++++++++++++ HDOJ/4821_autoAC.cpp | 89 ++++++++++++++ HDOJ/4822_autoAC.cpp | 148 +++++++++++++++++++++++ HDOJ/4823_autoAC.cpp | 39 ++++++ HDOJ/4824_autoAC.cpp | 57 +++++++++ HDOJ/4825_autoAC.cpp | 104 ++++++++++++++++ HDOJ/4826_autoAC.cpp | 49 ++++++++ HDOJ/4828_autoAC.cpp | 31 +++++ HDOJ/4829_autoAC.cpp | 107 +++++++++++++++++ HDOJ/4831_autoAC.cpp | 156 ++++++++++++++++++++++++ HDOJ/4832_autoAC.cpp | 116 ++++++++++++++++++ HDOJ/4833_autoAC.cpp | 100 ++++++++++++++++ HDOJ/4834_autoAC.cpp | 49 ++++++++ HDOJ/4836_autoAC.cpp | 132 ++++++++++++++++++++ HDOJ/4841_autoAC.cpp | 26 ++++ HDOJ/4845_autoAC.cpp | 77 ++++++++++++ HDOJ/4846_autoAC.cpp | 43 +++++++ HDOJ/4847_autoAC.cpp | 17 +++ HDOJ/4848_autoAC.cpp | 56 +++++++++ HDOJ/4849_autoAC.cpp | 56 +++++++++ HDOJ/4850_autoAC.cpp | 39 ++++++ HDOJ/4856_autoAC.cpp | 109 +++++++++++++++++ HDOJ/4857_autoAC.cpp | 82 +++++++++++++ HDOJ/4858_autoAC.cpp | 53 +++++++++ HDOJ/4859_autoAC.cpp | 158 ++++++++++++++++++++++++ HDOJ/4861_autoAC.cpp | 16 +++ HDOJ/4862_autoAC.cpp | 103 ++++++++++++++++ HDOJ/4863_autoAC.cpp | 132 ++++++++++++++++++++ HDOJ/4864_autoAC.cpp | 49 ++++++++ HDOJ/4865_autoAC.cpp | 92 ++++++++++++++ HDOJ/4866_autoAC.cpp | 169 ++++++++++++++++++++++++++ HDOJ/4867_autoAC.cpp | 134 +++++++++++++++++++++ HDOJ/4868_autoAC.cpp | 278 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/4869_autoAC.cpp | 56 +++++++++ HDOJ/4870_autoAC.cpp | 49 ++++++++ HDOJ/4871_autoAC.cpp | 232 ++++++++++++++++++++++++++++++++++++ HDOJ/4872_autoAC.cpp | 90 ++++++++++++++ HDOJ/4873_autoAC.cpp | 234 ++++++++++++++++++++++++++++++++++++ HDOJ/4876_autoAC.cpp | 80 +++++++++++++ HDOJ/4878_autoAC.cpp | 175 +++++++++++++++++++++++++++ HDOJ/4879_autoAC.cpp | 128 ++++++++++++++++++++ HDOJ/4882_autoAC.cpp | 24 ++++ HDOJ/4883_autoAC.cpp | 32 +++++ HDOJ/4884_autoAC.cpp | 41 +++++++ HDOJ/4885_autoAC.cpp | 130 ++++++++++++++++++++ HDOJ/4886_autoAC.cpp | 71 +++++++++++ HDOJ/4887_autoAC.cpp | 203 +++++++++++++++++++++++++++++++ HDOJ/4888_autoAC.cpp | 152 +++++++++++++++++++++++ HDOJ/4889_autoAC.cpp | 21 ++++ HDOJ/4890_autoAC.cpp | 206 ++++++++++++++++++++++++++++++++ HDOJ/4891_autoAC.cpp | 63 ++++++++++ HDOJ/4892_autoAC.cpp | 174 +++++++++++++++++++++++++++ HDOJ/4893_autoAC.cpp | 141 ++++++++++++++++++++++ HDOJ/4896_autoAC.cpp | 86 +++++++++++++ HDOJ/4897_autoAC.cpp | 183 ++++++++++++++++++++++++++++ HDOJ/4898_autoAC.cpp | 127 ++++++++++++++++++++ HDOJ/4899_autoAC.cpp | 101 ++++++++++++++++ 74 files changed, 7060 insertions(+) create mode 100644 HDOJ/4800_autoAC.cpp create mode 100644 HDOJ/4801_autoAC.cpp create mode 100644 HDOJ/4802_autoAC.cpp create mode 100644 HDOJ/4803_autoAC.cpp create mode 100644 HDOJ/4804_autoAC.cpp create mode 100644 HDOJ/4805_autoAC.cpp create mode 100644 HDOJ/4807_autoAC.cpp create mode 100644 HDOJ/4808_autoAC.cpp create mode 100644 HDOJ/4809_autoAC.cpp create mode 100644 HDOJ/4810_autoAC.cpp create mode 100644 HDOJ/4811_autoAC.cpp create mode 100644 HDOJ/4812_autoAC.cpp create mode 100644 HDOJ/4813_autoAC.cpp create mode 100644 HDOJ/4814_autoAC.cpp create mode 100644 HDOJ/4815_autoAC.cpp create mode 100644 HDOJ/4816_autoAC.cpp create mode 100644 HDOJ/4818_autoAC.cpp create mode 100644 HDOJ/4819_autoAC.cpp create mode 100644 HDOJ/4821_autoAC.cpp create mode 100644 HDOJ/4822_autoAC.cpp create mode 100644 HDOJ/4823_autoAC.cpp create mode 100644 HDOJ/4824_autoAC.cpp create mode 100644 HDOJ/4825_autoAC.cpp create mode 100644 HDOJ/4826_autoAC.cpp create mode 100644 HDOJ/4828_autoAC.cpp create mode 100644 HDOJ/4829_autoAC.cpp create mode 100644 HDOJ/4831_autoAC.cpp create mode 100644 HDOJ/4832_autoAC.cpp create mode 100644 HDOJ/4833_autoAC.cpp create mode 100644 HDOJ/4834_autoAC.cpp create mode 100644 HDOJ/4836_autoAC.cpp create mode 100644 HDOJ/4841_autoAC.cpp create mode 100644 HDOJ/4845_autoAC.cpp create mode 100644 HDOJ/4846_autoAC.cpp create mode 100644 HDOJ/4847_autoAC.cpp create mode 100644 HDOJ/4848_autoAC.cpp create mode 100644 HDOJ/4849_autoAC.cpp create mode 100644 HDOJ/4850_autoAC.cpp create mode 100644 HDOJ/4856_autoAC.cpp create mode 100644 HDOJ/4857_autoAC.cpp create mode 100644 HDOJ/4858_autoAC.cpp create mode 100644 HDOJ/4859_autoAC.cpp create mode 100644 HDOJ/4861_autoAC.cpp create mode 100644 HDOJ/4862_autoAC.cpp create mode 100644 HDOJ/4863_autoAC.cpp create mode 100644 HDOJ/4864_autoAC.cpp create mode 100644 HDOJ/4865_autoAC.cpp create mode 100644 HDOJ/4866_autoAC.cpp create mode 100644 HDOJ/4867_autoAC.cpp create mode 100644 HDOJ/4868_autoAC.cpp create mode 100644 HDOJ/4869_autoAC.cpp create mode 100644 HDOJ/4870_autoAC.cpp create mode 100644 HDOJ/4871_autoAC.cpp create mode 100644 HDOJ/4872_autoAC.cpp create mode 100644 HDOJ/4873_autoAC.cpp create mode 100644 HDOJ/4876_autoAC.cpp create mode 100644 HDOJ/4878_autoAC.cpp create mode 100644 HDOJ/4879_autoAC.cpp create mode 100644 HDOJ/4882_autoAC.cpp create mode 100644 HDOJ/4883_autoAC.cpp create mode 100644 HDOJ/4884_autoAC.cpp create mode 100644 HDOJ/4885_autoAC.cpp create mode 100644 HDOJ/4886_autoAC.cpp create mode 100644 HDOJ/4887_autoAC.cpp create mode 100644 HDOJ/4888_autoAC.cpp create mode 100644 HDOJ/4889_autoAC.cpp create mode 100644 HDOJ/4890_autoAC.cpp create mode 100644 HDOJ/4891_autoAC.cpp create mode 100644 HDOJ/4892_autoAC.cpp create mode 100644 HDOJ/4893_autoAC.cpp create mode 100644 HDOJ/4896_autoAC.cpp create mode 100644 HDOJ/4897_autoAC.cpp create mode 100644 HDOJ/4898_autoAC.cpp create mode 100644 HDOJ/4899_autoAC.cpp diff --git a/HDOJ/4800_autoAC.cpp b/HDOJ/4800_autoAC.cpp new file mode 100644 index 0000000..bfad0e3 --- /dev/null +++ b/HDOJ/4800_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +#include +#include +#include +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 +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4802_autoAC.cpp b/HDOJ/4802_autoAC.cpp new file mode 100644 index 0000000..22349d8 --- /dev/null +++ b/HDOJ/4802_autoAC.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +mapm; +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>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); + } +} diff --git a/HDOJ/4803_autoAC.cpp b/HDOJ/4803_autoAC.cpp new file mode 100644 index 0000000..fe8f76a --- /dev/null +++ b/HDOJ/4803_autoAC.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +using namespace std; +int x,y; +int main() +{ + while(~scanf("%d%d",&x,&y)) + { + if(y +#include +#include +#include +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< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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 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; jL; + 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;} + vectorL; + 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 +#include +#include +#include +#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; + queueq; + 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; +} diff --git a/HDOJ/4808_autoAC.cpp b/HDOJ/4808_autoAC.cpp new file mode 100644 index 0000000..a6de709 --- /dev/null +++ b/HDOJ/4808_autoAC.cpp @@ -0,0 +1,17 @@ +#include +#include +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; +} diff --git a/HDOJ/4809_autoAC.cpp b/HDOJ/4809_autoAC.cpp new file mode 100644 index 0000000..ccd97c6 --- /dev/null +++ b/HDOJ/4809_autoAC.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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; +} diff --git a/HDOJ/4810_autoAC.cpp b/HDOJ/4810_autoAC.cpp new file mode 100644 index 0000000..6e76e1a --- /dev/null +++ b/HDOJ/4810_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +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 +#include +#include +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; +} diff --git a/HDOJ/4812_autoAC.cpp b/HDOJ/4812_autoAC.cpp new file mode 100644 index 0000000..db0199e --- /dev/null +++ b/HDOJ/4812_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4813_autoAC.cpp b/HDOJ/4813_autoAC.cpp new file mode 100644 index 0000000..f8498f6 --- /dev/null +++ b/HDOJ/4813_autoAC.cpp @@ -0,0 +1,20 @@ +#include +#include +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 +#include +#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; +} diff --git a/HDOJ/4815_autoAC.cpp b/HDOJ/4815_autoAC.cpp new file mode 100644 index 0000000..46f7885 --- /dev/null +++ b/HDOJ/4815_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include +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=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; +} diff --git a/HDOJ/4816_autoAC.cpp b/HDOJ/4816_autoAC.cpp new file mode 100644 index 0000000..d18f737 --- /dev/null +++ b/HDOJ/4816_autoAC.cpp @@ -0,0 +1,111 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4818_autoAC.cpp b/HDOJ/4818_autoAC.cpp new file mode 100644 index 0000000..56b6b2e --- /dev/null +++ b/HDOJ/4818_autoAC.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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;kfabs(a[max_r][col])) + max_r = i; + if(fabs(a[max_r][col])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; +} diff --git a/HDOJ/4819_autoAC.cpp b/HDOJ/4819_autoAC.cpp new file mode 100644 index 0000000..251ca9d --- /dev/null +++ b/HDOJ/4819_autoAC.cpp @@ -0,0 +1,150 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4821_autoAC.cpp b/HDOJ/4821_autoAC.cpp new file mode 100644 index 0000000..67d00c8 --- /dev/null +++ b/HDOJ/4821_autoAC.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4822_autoAC.cpp b/HDOJ/4822_autoAC.cpp new file mode 100644 index 0000000..02bdf01 --- /dev/null +++ b/HDOJ/4822_autoAC.cpp @@ -0,0 +1,148 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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)); + } + } +} diff --git a/HDOJ/4823_autoAC.cpp b/HDOJ/4823_autoAC.cpp new file mode 100644 index 0000000..61f412b --- /dev/null +++ b/HDOJ/4823_autoAC.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +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<m) + { + m=(m-v)*k; + co++; + } + else + { + co=-1; + break; + } + } + cout< +#include +#include +#include +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 +#include +#include +#include +#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; inext[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; +} diff --git a/HDOJ/4826_autoAC.cpp b/HDOJ/4826_autoAC.cpp new file mode 100644 index 0000000..e064e1b --- /dev/null +++ b/HDOJ/4826_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4828_autoAC.cpp b/HDOJ/4828_autoAC.cpp new file mode 100644 index 0000000..d66b6e3 --- /dev/null +++ b/HDOJ/4828_autoAC.cpp @@ -0,0 +1,31 @@ +#include +#include +#include +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; +} diff --git a/HDOJ/4829_autoAC.cpp b/HDOJ/4829_autoAC.cpp new file mode 100644 index 0000000..14182f9 --- /dev/null +++ b/HDOJ/4829_autoAC.cpp @@ -0,0 +1,107 @@ +#include +#include +#include +#include +#include +#include +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]); + } + } + } +} diff --git a/HDOJ/4831_autoAC.cpp b/HDOJ/4831_autoAC.cpp new file mode 100644 index 0000000..dcd5667 --- /dev/null +++ b/HDOJ/4831_autoAC.cpp @@ -0,0 +1,156 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +vectorvec1[10010]; +vectorvec2[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; +} diff --git a/HDOJ/4832_autoAC.cpp b/HDOJ/4832_autoAC.cpp new file mode 100644 index 0000000..b579521 --- /dev/null +++ b/HDOJ/4832_autoAC.cpp @@ -0,0 +1,116 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4833_autoAC.cpp b/HDOJ/4833_autoAC.cpp new file mode 100644 index 0000000..435e666 --- /dev/null +++ b/HDOJ/4833_autoAC.cpp @@ -0,0 +1,100 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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]; +vectorvec[5010]; +vectorvec2[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; + mapmp; + 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; +} diff --git a/HDOJ/4834_autoAC.cpp b/HDOJ/4834_autoAC.cpp new file mode 100644 index 0000000..b157da8 --- /dev/null +++ b/HDOJ/4834_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4836_autoAC.cpp b/HDOJ/4836_autoAC.cpp new file mode 100644 index 0000000..ee8760f --- /dev/null +++ b/HDOJ/4836_autoAC.cpp @@ -0,0 +1,132 @@ +#include +#include +#include +#include +#include +#include +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;i0){ + 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<=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< +#include +#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; +} diff --git a/HDOJ/4845_autoAC.cpp b/HDOJ/4845_autoAC.cpp new file mode 100644 index 0000000..171a2f0 --- /dev/null +++ b/HDOJ/4845_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include +#include +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 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 +#include +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(l20) + p=0; + else + { p++; + if(p>=i) + { ans=i; + break; + } + } + } + } + if(ans>0) + l2=i; + else + r2=i-1; + } + printf("%d\n",l2); + } +} diff --git a/HDOJ/4847_autoAC.cpp b/HDOJ/4847_autoAC.cpp new file mode 100644 index 0000000..a06e1ac --- /dev/null +++ b/HDOJ/4847_autoAC.cpp @@ -0,0 +1,17 @@ +#include +#include +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; +} diff --git a/HDOJ/4848_autoAC.cpp b/HDOJ/4848_autoAC.cpp new file mode 100644 index 0000000..b4e0769 --- /dev/null +++ b/HDOJ/4848_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +using namespace std ; +const int INF=0xfffffff ; +int n ; +int dis[55][55],ti[55],vis[55],ans ; +void floyd() +{ + for(int k=0 ;kans)return ; + for(int i=1 ;iti[i])return ; + for(int i=1 ;i +#include +#include +#include +#include +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 +#include +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; +} diff --git a/HDOJ/4856_autoAC.cpp b/HDOJ/4856_autoAC.cpp new file mode 100644 index 0000000..ea4699f --- /dev/null +++ b/HDOJ/4856_autoAC.cpp @@ -0,0 +1,109 @@ +#include +#include +#include +#include +#include +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 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 +#include +#include +#include +#include +#include +#include +#include +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_queueque; +vectorvec; +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< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int n, m, q; +vector 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; +} diff --git a/HDOJ/4859_autoAC.cpp b/HDOJ/4859_autoAC.cpp new file mode 100644 index 0000000..693de0b --- /dev/null +++ b/HDOJ/4859_autoAC.cpp @@ -0,0 +1,158 @@ +#include +#include +#include +#include +#include +#include +#include +#include +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)); + queueq; + 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]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=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; +} diff --git a/HDOJ/4861_autoAC.cpp b/HDOJ/4861_autoAC.cpp new file mode 100644 index 0000000..a78f8f3 --- /dev/null +++ b/HDOJ/4861_autoAC.cpp @@ -0,0 +1,16 @@ +#include +#include +#include +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; +} diff --git a/HDOJ/4862_autoAC.cpp b/HDOJ/4862_autoAC.cpp new file mode 100644 index 0000000..8691df4 --- /dev/null +++ b/HDOJ/4862_autoAC.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +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 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 ; +} diff --git a/HDOJ/4863_autoAC.cpp b/HDOJ/4863_autoAC.cpp new file mode 100644 index 0000000..f7a9da4 --- /dev/null +++ b/HDOJ/4863_autoAC.cpp @@ -0,0 +1,132 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define N 333 +#define LL long long +#define mod 10007ll +#define inf 0XFFFFFFF +#define pii pair +#define mp make_pair +#define eps 1e-3 +int n; +vector 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(); +} diff --git a/HDOJ/4864_autoAC.cpp b/HDOJ/4864_autoAC.cpp new file mode 100644 index 0000000..08b347b --- /dev/null +++ b/HDOJ/4864_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +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=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); + } +} diff --git a/HDOJ/4865_autoAC.cpp b/HDOJ/4865_autoAC.cpp new file mode 100644 index 0000000..3e0896c --- /dev/null +++ b/HDOJ/4865_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define maxn 55 +using namespace std; +double dp[55][3]; +int pre[55][3]; +map 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 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; +} diff --git a/HDOJ/4866_autoAC.cpp b/HDOJ/4866_autoAC.cpp new file mode 100644 index 0000000..cb28196 --- /dev/null +++ b/HDOJ/4866_autoAC.cpp @@ -0,0 +1,169 @@ +#include +#include +#include +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 ; +} diff --git a/HDOJ/4867_autoAC.cpp b/HDOJ/4867_autoAC.cpp new file mode 100644 index 0000000..31f2152 --- /dev/null +++ b/HDOJ/4867_autoAC.cpp @@ -0,0 +1,134 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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 >tree[maxn<<2]; +mapmp; +int mlen,a[maxn]; +vector > getpre(int n) +{ + vector >res; + for(int i=9;i>=0;--i) + if(n&(1<>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<=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; + pairpii; + 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; +} diff --git a/HDOJ/4868_autoAC.cpp b/HDOJ/4868_autoAC.cpp new file mode 100644 index 0000000..69256c2 --- /dev/null +++ b/HDOJ/4868_autoAC.cpp @@ -0,0 +1,278 @@ +#include +#include +#include +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')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 + { + if(j!=mapNum[n]) + { + strcpy(sta1[++top],tag); + flag++; + sta2[top]=0; + for(j=0; j +#include +#include +#include +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=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; +} diff --git a/HDOJ/4870_autoAC.cpp b/HDOJ/4870_autoAC.cpp new file mode 100644 index 0000000..f4117b5 --- /dev/null +++ b/HDOJ/4870_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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 T CMP_MIN(T a, T b) { return a < b; } +template T CMP_MAX(T a, T b) { return a > b; } +template T MAX(T a, T b) { return a > b ? a : b; } +template T MIN(T a, T b) { return a < b ? a : b; } +template T GCD(T a, T b) { return b ? GCD(b, a%b) : a; } +template 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; +} diff --git a/HDOJ/4871_autoAC.cpp b/HDOJ/4871_autoAC.cpp new file mode 100644 index 0000000..8162de9 --- /dev/null +++ b/HDOJ/4871_autoAC.cpp @@ -0,0 +1,232 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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_queueq; + 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] +#include +#include +#include +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 +#include +#include +#include +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; +} diff --git a/HDOJ/4876_autoAC.cpp b/HDOJ/4876_autoAC.cpp new file mode 100644 index 0000000..73db02b --- /dev/null +++ b/HDOJ/4876_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +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 +#include +#include +#include +#include +#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 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 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; +} diff --git a/HDOJ/4879_autoAC.cpp b/HDOJ/4879_autoAC.cpp new file mode 100644 index 0000000..3eff860 --- /dev/null +++ b/HDOJ/4879_autoAC.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 200000 + 5; +const int INF = 1000000000; +const int Mod = 1000000000 + 7; +typedef long long LL; +typedef pair 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 > Mx, My; +set::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; +} diff --git a/HDOJ/4882_autoAC.cpp b/HDOJ/4882_autoAC.cpp new file mode 100644 index 0000000..2e2559e --- /dev/null +++ b/HDOJ/4882_autoAC.cpp @@ -0,0 +1,24 @@ +#include +#include +#include +#include +#define N 101000 +using namespace std; +struct YYC +{ + int x,y; + bool operator < (const YYC &a)const + {return x*a.y +#include +#include +#include +#include +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 +#include +#include +#include +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=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; +} diff --git a/HDOJ/4885_autoAC.cpp b/HDOJ/4885_autoAC.cpp new file mode 100644 index 0000000..b40b5d6 --- /dev/null +++ b/HDOJ/4885_autoAC.cpp @@ -0,0 +1,130 @@ +#include +#include +#include +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 ; +} diff --git a/HDOJ/4886_autoAC.cpp b/HDOJ/4886_autoAC.cpp new file mode 100644 index 0000000..d177cd1 --- /dev/null +++ b/HDOJ/4886_autoAC.cpp @@ -0,0 +1,71 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +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=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=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 +#include +#include +#include +#include +#include +#include +#include +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>1; + } +} +void check(bool a[33],int n) { + for(int i=0; i>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; i0) n1.a[0][a1[i]-1]=1; + n1.a[0][n-1]=1; + for(i=0; im) 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; +} diff --git a/HDOJ/4888_autoAC.cpp b/HDOJ/4888_autoAC.cpp new file mode 100644 index 0000000..fcc29e9 --- /dev/null +++ b/HDOJ/4888_autoAC.cpp @@ -0,0 +1,152 @@ +#include +#include +#include +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(front0) + { + 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 ; +} diff --git a/HDOJ/4889_autoAC.cpp b/HDOJ/4889_autoAC.cpp new file mode 100644 index 0000000..f59af45 --- /dev/null +++ b/HDOJ/4889_autoAC.cpp @@ -0,0 +1,21 @@ +#include +#include +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 +#include +#include +#include +#include +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; +} diff --git a/HDOJ/4891_autoAC.cpp b/HDOJ/4891_autoAC.cpp new file mode 100644 index 0000000..90e52e5 --- /dev/null +++ b/HDOJ/4891_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +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; i100000) + break; + } + if(sum>100000) + printf("doge\n"); + else + printf("%I64d\n",sum); + } + return 0; +} diff --git a/HDOJ/4892_autoAC.cpp b/HDOJ/4892_autoAC.cpp new file mode 100644 index 0000000..710a977 --- /dev/null +++ b/HDOJ/4892_autoAC.cpp @@ -0,0 +1,174 @@ +#include +#include +#include +using namespace std; +#define prt(k) cout<<#k" = "< +#include +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 +int cnt; +bool inq[MAXN]; +void spfa(double d[], int n) +{ + queue q; + for(int i=0;i 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<= 0) printf("Impossible\n"); + else printf("%.12f\n", ans); + } + return 0; +} diff --git a/HDOJ/4893_autoAC.cpp b/HDOJ/4893_autoAC.cpp new file mode 100644 index 0000000..11b9540 --- /dev/null +++ b/HDOJ/4893_autoAC.cpp @@ -0,0 +1,141 @@ +#include +#include +#include +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(posr) 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])>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(Rr) 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(Rr) 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; +} diff --git a/HDOJ/4896_autoAC.cpp b/HDOJ/4896_autoAC.cpp new file mode 100644 index 0000000..18a2ffd --- /dev/null +++ b/HDOJ/4896_autoAC.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include +#include +#define eps 1e-9 +#define LL long long +#define mod 2333333 +using namespace std; +map 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 +#include +#include +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[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[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[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 +#include +#include +#include +#include +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) 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>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=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;in) break; + tmp.init(i,j); + sub[++tsub]=tmp; + } + } + sort(sub+1,sub+tsub+1); + tmp=work(); + output(tmp); + } + return 0; +} diff --git a/HDOJ/4899_autoAC.cpp b/HDOJ/4899_autoAC.cpp new file mode 100644 index 0000000..2f852c0 --- /dev/null +++ b/HDOJ/4899_autoAC.cpp @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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; +}