From b39288d6effbda6129ce68e95bf4ab43a6af4c45 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Tue, 13 Sep 2016 04:55:33 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 5400-5504(END by now) --- HDOJ/5400_autoAC.cpp | 61 ++++++ HDOJ/5401_autoAC.cpp | 51 +++++ HDOJ/5402_autoAC.cpp | 105 ++++++++++ HDOJ/5405_autoAC.cpp | 182 +++++++++++++++++ HDOJ/5406_autoAC.cpp | 457 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/5407_autoAC.cpp | 47 +++++ HDOJ/5409_autoAC.cpp | 77 ++++++++ HDOJ/5410_autoAC.cpp | 30 +++ HDOJ/5411_autoAC.cpp | 62 ++++++ HDOJ/5412_autoAC.cpp | 192 ++++++++++++++++++ HDOJ/5413_autoAC.cpp | 97 +++++++++ HDOJ/5414_autoAC.cpp | 52 +++++ HDOJ/5416_autoAC.cpp | 70 +++++++ HDOJ/5417_autoAC.cpp | 21 ++ HDOJ/5418_autoAC.cpp | 63 ++++++ HDOJ/5419_autoAC.cpp | 46 +++++ HDOJ/5420_autoAC.cpp | 124 ++++++++++++ HDOJ/5421_autoAC.cpp | 73 +++++++ HDOJ/5422_autoAC.cpp | 19 ++ HDOJ/5423_autoAC.cpp | 44 +++++ HDOJ/5424_autoAC.cpp | 47 +++++ HDOJ/5425_autoAC.cpp | 53 +++++ HDOJ/5427_autoAC.cpp | 52 +++++ HDOJ/5428_autoAC.cpp | 37 ++++ HDOJ/5429_autoAC.cpp | 309 +++++++++++++++++++++++++++++ HDOJ/5430_autoAC.cpp | 31 +++ HDOJ/5431_autoAC.cpp | 81 ++++++++ HDOJ/5432_autoAC.cpp | 45 +++++ HDOJ/5433_autoAC.cpp | 69 +++++++ HDOJ/5434_autoAC.cpp | 101 ++++++++++ HDOJ/5435_autoAC.cpp | 65 ++++++ HDOJ/5437_autoAC.cpp | 79 ++++++++ HDOJ/5438_autoAC.cpp | 70 +++++++ HDOJ/5439_autoAC.cpp | 77 ++++++++ HDOJ/5440_autoAC.cpp | 145 ++++++++++++++ HDOJ/5441_autoAC.cpp | 78 ++++++++ HDOJ/5442_autoAC.cpp | 90 +++++++++ HDOJ/5443_autoAC.cpp | 46 +++++ HDOJ/5444_autoAC.cpp | 80 ++++++++ HDOJ/5445_autoAC.cpp | 90 +++++++++ HDOJ/5446_autoAC.cpp | 81 ++++++++ HDOJ/5448_autoAC.cpp | 49 +++++ HDOJ/5449_autoAC.cpp | 95 +++++++++ HDOJ/5450_autoAC.cpp | 91 +++++++++ HDOJ/5451_autoAC.cpp | 74 +++++++ HDOJ/5452_autoAC.cpp | 123 ++++++++++++ HDOJ/5454_autoAC.cpp | 157 +++++++++++++++ HDOJ/5455_autoAC.cpp | 92 +++++++++ HDOJ/5456_autoAC.cpp | 77 ++++++++ HDOJ/5457_autoAC.cpp | 340 ++++++++++++++++++++++++++++++++ HDOJ/5458_autoAC.cpp | 310 +++++++++++++++++++++++++++++ HDOJ/5459_autoAC.cpp | 46 +++++ HDOJ/5460_autoAC.cpp | 59 ++++++ HDOJ/5461_autoAC.cpp | 47 +++++ HDOJ/5462_autoAC.cpp | 204 +++++++++++++++++++ HDOJ/5463_autoAC.cpp | 34 ++++ HDOJ/5464_autoAC.cpp | 31 +++ HDOJ/5465_autoAC.cpp | 117 +++++++++++ HDOJ/5467_autoAC.cpp | 236 ++++++++++++++++++++++ HDOJ/5468_autoAC.cpp | 166 ++++++++++++++++ HDOJ/5469_autoAC.cpp | 77 ++++++++ HDOJ/5470_autoAC.cpp | 114 +++++++++++ HDOJ/5471_autoAC.cpp | 110 +++++++++++ HDOJ/5473_autoAC.cpp | 93 +++++++++ HDOJ/5475_autoAC.cpp | 83 ++++++++ HDOJ/5476_autoAC.cpp | 33 ++++ HDOJ/5479_autoAC.cpp | 51 +++++ HDOJ/5481_autoAC.cpp | 97 +++++++++ HDOJ/5483_autoAC.cpp | 138 +++++++++++++ HDOJ/5486_autoAC.cpp | 144 ++++++++++++++ HDOJ/5487_autoAC.cpp | 104 ++++++++++ HDOJ/5489_autoAC.cpp | 103 ++++++++++ HDOJ/5490_autoAC.cpp | 85 ++++++++ HDOJ/5491_autoAC.cpp | 112 +++++++++++ HDOJ/5492_autoAC.cpp | 97 +++++++++ HDOJ/5493_autoAC.cpp | 132 +++++++++++++ HDOJ/5494_autoAC.cpp | 44 +++++ HDOJ/5495_autoAC.cpp | 34 ++++ HDOJ/5496_autoAC.cpp | 39 ++++ HDOJ/5497_autoAC.cpp | 60 ++++++ HDOJ/5498_autoAC.cpp | 99 ++++++++++ HDOJ/5499_autoAC.cpp | 68 +++++++ HDOJ/5500_autoAC.cpp | 40 ++++ HDOJ/5501_autoAC.cpp | 76 +++++++ HDOJ/5502_autoAC.cpp | 42 ++++ HDOJ/5503_autoAC.cpp | 51 +++++ HDOJ/5504_autoAC.cpp | 46 +++++ 87 files changed, 8119 insertions(+) create mode 100644 HDOJ/5400_autoAC.cpp create mode 100644 HDOJ/5401_autoAC.cpp create mode 100644 HDOJ/5402_autoAC.cpp create mode 100644 HDOJ/5405_autoAC.cpp create mode 100644 HDOJ/5406_autoAC.cpp create mode 100644 HDOJ/5407_autoAC.cpp create mode 100644 HDOJ/5409_autoAC.cpp create mode 100644 HDOJ/5410_autoAC.cpp create mode 100644 HDOJ/5411_autoAC.cpp create mode 100644 HDOJ/5412_autoAC.cpp create mode 100644 HDOJ/5413_autoAC.cpp create mode 100644 HDOJ/5414_autoAC.cpp create mode 100644 HDOJ/5416_autoAC.cpp create mode 100644 HDOJ/5417_autoAC.cpp create mode 100644 HDOJ/5418_autoAC.cpp create mode 100644 HDOJ/5419_autoAC.cpp create mode 100644 HDOJ/5420_autoAC.cpp create mode 100644 HDOJ/5421_autoAC.cpp create mode 100644 HDOJ/5422_autoAC.cpp create mode 100644 HDOJ/5423_autoAC.cpp create mode 100644 HDOJ/5424_autoAC.cpp create mode 100644 HDOJ/5425_autoAC.cpp create mode 100644 HDOJ/5427_autoAC.cpp create mode 100644 HDOJ/5428_autoAC.cpp create mode 100644 HDOJ/5429_autoAC.cpp create mode 100644 HDOJ/5430_autoAC.cpp create mode 100644 HDOJ/5431_autoAC.cpp create mode 100644 HDOJ/5432_autoAC.cpp create mode 100644 HDOJ/5433_autoAC.cpp create mode 100644 HDOJ/5434_autoAC.cpp create mode 100644 HDOJ/5435_autoAC.cpp create mode 100644 HDOJ/5437_autoAC.cpp create mode 100644 HDOJ/5438_autoAC.cpp create mode 100644 HDOJ/5439_autoAC.cpp create mode 100644 HDOJ/5440_autoAC.cpp create mode 100644 HDOJ/5441_autoAC.cpp create mode 100644 HDOJ/5442_autoAC.cpp create mode 100644 HDOJ/5443_autoAC.cpp create mode 100644 HDOJ/5444_autoAC.cpp create mode 100644 HDOJ/5445_autoAC.cpp create mode 100644 HDOJ/5446_autoAC.cpp create mode 100644 HDOJ/5448_autoAC.cpp create mode 100644 HDOJ/5449_autoAC.cpp create mode 100644 HDOJ/5450_autoAC.cpp create mode 100644 HDOJ/5451_autoAC.cpp create mode 100644 HDOJ/5452_autoAC.cpp create mode 100644 HDOJ/5454_autoAC.cpp create mode 100644 HDOJ/5455_autoAC.cpp create mode 100644 HDOJ/5456_autoAC.cpp create mode 100644 HDOJ/5457_autoAC.cpp create mode 100644 HDOJ/5458_autoAC.cpp create mode 100644 HDOJ/5459_autoAC.cpp create mode 100644 HDOJ/5460_autoAC.cpp create mode 100644 HDOJ/5461_autoAC.cpp create mode 100644 HDOJ/5462_autoAC.cpp create mode 100644 HDOJ/5463_autoAC.cpp create mode 100644 HDOJ/5464_autoAC.cpp create mode 100644 HDOJ/5465_autoAC.cpp create mode 100644 HDOJ/5467_autoAC.cpp create mode 100644 HDOJ/5468_autoAC.cpp create mode 100644 HDOJ/5469_autoAC.cpp create mode 100644 HDOJ/5470_autoAC.cpp create mode 100644 HDOJ/5471_autoAC.cpp create mode 100644 HDOJ/5473_autoAC.cpp create mode 100644 HDOJ/5475_autoAC.cpp create mode 100644 HDOJ/5476_autoAC.cpp create mode 100644 HDOJ/5479_autoAC.cpp create mode 100644 HDOJ/5481_autoAC.cpp create mode 100644 HDOJ/5483_autoAC.cpp create mode 100644 HDOJ/5486_autoAC.cpp create mode 100644 HDOJ/5487_autoAC.cpp create mode 100644 HDOJ/5489_autoAC.cpp create mode 100644 HDOJ/5490_autoAC.cpp create mode 100644 HDOJ/5491_autoAC.cpp create mode 100644 HDOJ/5492_autoAC.cpp create mode 100644 HDOJ/5493_autoAC.cpp create mode 100644 HDOJ/5494_autoAC.cpp create mode 100644 HDOJ/5495_autoAC.cpp create mode 100644 HDOJ/5496_autoAC.cpp create mode 100644 HDOJ/5497_autoAC.cpp create mode 100644 HDOJ/5498_autoAC.cpp create mode 100644 HDOJ/5499_autoAC.cpp create mode 100644 HDOJ/5500_autoAC.cpp create mode 100644 HDOJ/5501_autoAC.cpp create mode 100644 HDOJ/5502_autoAC.cpp create mode 100644 HDOJ/5503_autoAC.cpp create mode 100644 HDOJ/5504_autoAC.cpp diff --git a/HDOJ/5400_autoAC.cpp b/HDOJ/5400_autoAC.cpp new file mode 100644 index 0000000..91026a2 --- /dev/null +++ b/HDOJ/5400_autoAC.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN= 100002; +int a[MAXN], m, n, b1, b2, len[MAXN], ch[MAXN]; +long long ans; +int main() +{ + int i; + while(scanf("%d%d%d", &n, &b1, &b2) != -1) + { + for(i = 1; i <= n; i++) + { + scanf("%d", &a[i]); + } + ans = 0; + len[1] = 1; + for(i = 2; i <= n; i++) + { + ch[i] = a[i] - a[i-1]; + if(i == 2) + { + if(a[2]-a[1] == b1 || a[2] - a[1] == b2) + len[i] = 2; + else len[i] = 1; + } + else + { + if(ch[i] == ch[i-1]) + { + if(ch[i] == b1 || ch[i] == b2) + len[i] = len[i-1] + 1; + else + len[i] = 1; + } + else if(ch[i] == b2 && ch[i-1] == b1) + { + len[i] = len[i-1] + 1; + } + else if(ch[i] == b1 || ch[i] == b2) + { + len[i] = 2; + } + else + { + len[i] = 1; + } + } + } + for(i = 1; i<= n; i++) + { + ans += len[i]; + } + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5401_autoAC.cpp b/HDOJ/5401_autoAC.cpp new file mode 100644 index 0000000..e3815b9 --- /dev/null +++ b/HDOJ/5401_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define ll long long +#define pi acos(-1) +#define PLL pair +#define PLLL pair +#define MP make_pair +using namespace std; +const ll mod = 1e9+7; +const ll maxn= 1000+10; +ll m,a[maxn],b[maxn],c[maxn],d[maxn],l[maxn],ans[maxn],s[maxn],cc[maxn],dd[maxn]; +map ma; +ll calc(ll p,ll x,ll y){ + if(p==0) return 0; + PLLL r=MP(MP(p,x),y); + if(ma.find(r)!=ma.end()) return ma[r]; + if(x=s[a[p]]) return ma[r]=(calc(a[p],x,c[p])+calc(b[p],y-s[a[p]],d[p])+l[p])%mod; + else if(x>=s[a[p]]&&y +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const LL base = 1e9 + 7; +const int maxn = 105; +LL T, n, m, a[maxn][maxn], sum, x, y; +inline void read(int &x) +{ + char ch; + while ((ch = getchar())<'0' || ch>'9'); + x = ch - '0'; + while ((ch = getchar()) >= '0' && ch <= '9') x = x * 10 + ch - '0'; +} +void get() +{ + x = 1; y = 2; + for (int i = 1; i <= n;i++) + for (int j = 1; j <= m; j++) + if (((i + j) & 1) && a[x][y] > a[i][j]) x = i, y = j; +} +int main() +{ + while (scanf("%lld%lld", &n, &m) !=EOF) + { + sum = 0; + for (int i = 1; i <= n;i++) + for (int j = 1; j <= m; j++) + { + scanf("%lld", &a[i][j]); + sum += a[i][j]; + } + if (n & 1 || m & 1) + { + printf("%lld\n", sum); + if (n & 1) + { + for (int i = 1; i <= n; i++) + { + for (int j = 1; j < m; j++) + if (i & 1) printf("R"); else printf("L"); + if (i < n) printf("D"); else printf("\n"); + } + } + else + { + for (int i = 1; i <= m; i++) + { + for (int j = 1; j < n; j++) + if (i & 1) printf("D"); else printf("U"); + if (i < m) printf("R"); else printf("\n"); + } + } + } + else + { + get(); + printf("%lld\n", sum - a[x][y]); + for (int i = 1; i <= n; i += 2) + { + if (x == i || x == i + 1) + { + for (int j = 1; j < y; j++) + { + if (j & 1) printf("D"); else printf("U"); + printf("R"); + } + if (y < m) printf("R"); + for (int j = y + 1; j <= m; j++) + { + if (j & 1) printf("U"); else printf("D"); + if (j < m) printf("R"); + } + if (i < n - 1) printf("D"); + } + else if (i < x) + { + for (int j = 1; j < m; j++) printf("R"); + printf("D"); + for (int j = 1; j < m; j++) printf("L"); + printf("D"); + } + else + { + for (int j = 1; j < m; j++) printf("L"); + printf("D"); + for (int j = 1; j < m; j++) printf("R"); + if (i < n - 1) printf("D"); + } + } + printf("\n"); + } + } + return 0; +} diff --git a/HDOJ/5405_autoAC.cpp b/HDOJ/5405_autoAC.cpp new file mode 100644 index 0000000..24d204c --- /dev/null +++ b/HDOJ/5405_autoAC.cpp @@ -0,0 +1,182 @@ +#include +#include +#include +#include +#include +using namespace std; +#define maxn 200007 +#define inf 1000000000 +#define ll long long +ll mod = 1000000007; +struct Node{ + Node *fa,*ch[2]; + bool rev,root; + ll val,s1,s2,s3,s4; +}; +Node pool[maxn]; +Node *nil,*tree[maxn]; +int cnt = 0; +void init(){ + cnt = 1; + nil = tree[0] = pool; + nil->ch[0] = nil->ch[1] = nil; + nil->s1 = nil->s2 = nil->val = nil->s3 = nil->s4 = 0; +} +Node *newnode(ll val,Node *f){ + pool[cnt].fa = f; + pool[cnt].ch[0]=pool[cnt].ch[1]=nil; + pool[cnt].rev = false; + pool[cnt].root = true; + pool[cnt].val = val; + pool[cnt].s1 = 0; + pool[cnt].s2 = 0; + pool[cnt].s3 = 0; + pool[cnt].s4 = 0; + return &pool[cnt++]; +} +void update_rev(Node *x){ + if(x == nil) return ; + x->rev = !x->rev; + swap(x->ch[0],x->ch[1]); +} +void update(Node *x){ + if(x == nil) return ; + x->s2 = x->s1 + x->val; + x->s4 = x->s3; + if(x->ch[0] != nil){ + x->s2 += x->ch[0]->s2; + if(x->s2 >= mod) + x->s2 -= mod; + x->s4 += x->ch[0]->s4; + x->s4 %= mod; + } + if(x->ch[1] != nil){ + x->s2 += x->ch[1]->s2; + if(x->s2 >= mod) + x->s2 -= mod; + x->s4 += x->ch[1]->s4; + x->s4 %= mod; + } +} +void pushdown(Node *x){ + if(x->rev != false){ + update_rev(x->ch[0]); + update_rev(x->ch[1]); + x->rev = false; + } +} +void push(Node *x){ + if(!x->root) push(x->fa); + pushdown(x); +} +void rotate(Node *x){ + Node *f = x->fa, *ff = f->fa; + int t = (f->ch[1] == x); + if(f->root) + x->root = true, f->root = false; + else ff->ch[ff->ch[1] == f] = x; + x->fa = ff; + f->ch[t] = x->ch[t^1]; + x->ch[t^1]->fa = f; + x->ch[t^1] = f; + f->fa = x; + update(f); +} +void splay(Node *x){ + push(x); + Node *f, *ff; + while(!x->root){ + f = x->fa,ff = f->fa; + if(!f->root) + if((ff->ch[1]==f)&&(f->ch[1] == x)) rotate(f); + else rotate(x); + rotate(x); + } + update(x); +} +Node *access(Node *x){ + Node *y = nil,*z; + while(x != nil){ + splay(x); + z = x->ch[1]; + x->ch[1]->root = true; + (x->ch[1] = y)->root = false; + update(z); + x->s1 += z->s2; + x->s3 += (z->s2*z->s2); + x->s1 %= mod; + x->s3 %= mod; + x->s1 -= y->s2; + x->s3 -= y->s2*y->s2; + x->s1 %= mod; + x->s3 %= mod; + update(x); + y = x; + x = x->fa; + } + return y; +} +void be_root(Node *x){ + access(x); + splay(x); + update_rev(x); +} +int value[maxn]; +vector head[maxn]; +void dfs(int u,int f){ + tree[u]->fa = tree[f]; + for(int i = 0;i < head[u].size() ;i++){ + int v = head[u][i]; + if(v == f) continue; + dfs(v,u); + tree[u]->s1 += tree[v]->s2; + tree[u]->s1 %= mod; + tree[u]->s3 += tree[v]->s2*tree[v]->s2; + tree[u]->s3 %= mod; + } + update(tree[u]); +} +int main(){ + int n,m; + while(scanf("%d%d",&n,&m)!=EOF){ + for(int i = 1;i <= n; i++) + scanf("%d",&value[i]); + for(int i = 0;i <= n; i++) + head[i].clear(); + int u,v; + for(int i = 1;i < n; i++){ + scanf("%d%d",&v,&u); + head[v].push_back(u); + head[u].push_back(v); + } + init(); + for(int i=1;i <= n;i++) + tree[i] = newnode(value[i],nil); + dfs(1,0); + ll total = 0; + for(int i = 1;i <= n; i++) + total += value[i]; + total %= mod; + int t; + for(int i = 0;i < m; i++){ + scanf("%d%d%d",&t,&u,&v); + if(t == 1){ + be_root(tree[u]); + access(tree[u]); + total = total + v - tree[u]->val; + total %= mod; + tree[u]->val = v; + update(tree[u]); + } + else { + be_root(tree[u]); + access(tree[v]); + splay(tree[v]); + ll ans = total*total%mod-tree[v]->s4; + ans = (ans%mod+mod)%mod; + printf("%I64d\n",ans); + } + } + } + return 0; +} diff --git a/HDOJ/5406_autoAC.cpp b/HDOJ/5406_autoAC.cpp new file mode 100644 index 0000000..8fe5283 --- /dev/null +++ b/HDOJ/5406_autoAC.cpp @@ -0,0 +1,457 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 1005; +struct A{ + int H, D; + bool operator<(const A rhs)const{ + if(H != rhs.H) + return H > rhs.H; + else + return D < rhs.D; + } +}arr[MAXN]; +int N; +int dval[MAXN], dvn; +#define MAXP 2010 +#define MAXQ 1000005 +#define MAXI 0x7fffffff +#define MAXC 0x0fffffff +#define BIGM MAXC +struct EDGE{ + int st, ed; + int flow; + int low; + int upf; + int cost; + int hnext; + int tnext; + int hprev; + int tprev; + char set; +}edge[MAXQ+MAXP]; +int ecnt; +int ecnt2; +int sece; +bool search_method; +struct NODE{ + int head; + int tail; + int d; + int pi; + int pred; + int depth; +}node[MAXP]; +int ncnt; +struct LOOP{ + int e; + int prev; + int next; +}loop[MAXP+3]; +int lcnt; +int addedge(int a, int b, int low, int upf, int cost, int &cnt) +{ + edge[cnt].st = a; + edge[cnt].ed = b; + edge[cnt].low = low; + edge[cnt].upf = upf; + edge[cnt].cost = cost; + edge[cnt].hnext = -1; + edge[cnt].tnext = -1; + edge[cnt].hprev = -1; + edge[cnt].tprev = -1; + cnt++; + return (cnt - 1); +} +void insert_tree(int j) +{ + int a, b; + a = edge[j].st; + b = edge[j].ed; + edge[j].hprev = -1; + edge[j].hnext = node[a].head; + if(node[a].head >= 0) + edge[node[a].head].hprev = j; + node[a].head = j; + edge[j].tprev = -1; + edge[j].tnext = node[b].tail; + if(node[b].tail >= 0) + edge[node[b].tail].tprev = j; + node[b].tail = j; +} +void delete_tree(int j) +{ + int a, b; + a = edge[j].st; + b = edge[j].ed; + if(edge[j].hprev >= 0) + { + edge[edge[j].hprev].hnext = edge[j].hnext; + }else{ + node[a].head = edge[j].hnext; + } + if(edge[j].hnext >= 0) + { + edge[edge[j].hnext].hprev = edge[j].hprev; + } + edge[j].hprev = -1; + edge[j].hnext = -1; + if(edge[j].tprev >= 0) + { + edge[edge[j].tprev].tnext = edge[j].tnext; + }else{ + node[b].tail = edge[j].tnext; + } + if(edge[j].tnext >= 0) + { + edge[edge[j].tnext].tprev = edge[j].tprev; + } + edge[j].tprev = -1; + edge[j].tnext = -1; +} +void M_init() +{ + int i, j; + node[0].d = 0; + node[0].head = -1; + node[0].tail = -1; + for(i=0;i 0) + { + j = addedge(i, 0, 0, MAXC, BIGM, ecnt2); + edge[j].flow = node[i].d; + }else{ + j = addedge(0, i, 0, MAXC, BIGM, ecnt2); + edge[j].flow = -node[i].d; + } + edge[j].set = 'T'; + insert_tree(j); + } +} +void calc_pi(int root, int val, int dep, int pred) +{ + int j; + node[root].pi = val; + node[root].depth = dep; + node[root].pred = pred; + for(j=node[root].head;j!=-1;j=edge[j].hnext) + { + if(j != pred) + { + calc_pi(edge[j].ed, val - edge[j].cost, dep + 1, j); + } + } + for(j=node[root].tail;j!=-1;j=edge[j].tnext) + { + if(j != pred) + { + calc_pi(edge[j].st, val + edge[j].cost, dep + 1, j); + } + } +} +int calc_dual1() +{ + int i, ret = -1, dual0 = -1, dual; + for(i=0;i 0)) + { + dual = labs(dual); + if(dual > dual0) + { + ret = i; + dual0 = dual; + } + } + } + return ret; +} +int calc_dual2() +{ + int i, dual; + for(i=sece;i 0)) + { + sece = i + 1; + return i; + } + } + for(i=0;i 0)) + { + sece = i + 1; + return i; + } + } + return -1; +} +bool augment(int rda) +{ + int p, q; + int pl, ql, pp, qp, maxflow; + bool flagp, flagq, flag, ret; + lcnt = 0; + if(edge[rda].set == 'L') + { + p = edge[rda].st; + q = edge[rda].ed; + }else{ + q = edge[rda].st; + p = edge[rda].ed; + } + loop[lcnt].e = rda; + loop[lcnt].prev = 1; + loop[lcnt].next = 2; + pl = 1; + ql = 2; + loop[pl].e = -1; + loop[pl].next = 0; + loop[pl].prev = -1; + loop[ql].e = -1; + loop[ql].next = -1; + loop[ql].prev = 0; + lcnt = 3; + maxflow = edge[rda].upf - edge[rda].low; + while(p != q) + { + if(node[p].depth > node[q].depth) + { + flagp = true; + flagq = false; + }else if(node[p].depth < node[q].depth) + { + flagp = false; + flagq = true; + }else{ + flagp = true; + flagq = true; + } + if(flagp) + { + pp = node[p].pred; + if(edge[pp].ed == p) + { + maxflow = min(maxflow, edge[pp].upf - edge[pp].flow); + p = edge[pp].st; + }else{ + maxflow = min(maxflow, edge[pp].flow - edge[pp].low); + p = edge[pp].ed; + } + loop[pl].e = pp; + loop[pl].prev = lcnt; + loop[lcnt].e = -1; + loop[lcnt].next = pl; + loop[lcnt].prev = -1; + pl = lcnt; + lcnt++; + } + if(flagq) + { + qp = node[q].pred; + if(edge[qp].st == q) + { + maxflow = min(maxflow, edge[qp].upf - edge[qp].flow); + q = edge[qp].ed; + }else{ + maxflow = min(maxflow, edge[qp].flow - edge[qp].low); + q = edge[qp].st; + } + loop[ql].e = qp; + loop[ql].next = lcnt; + loop[lcnt].e = -1; + loop[lcnt].next = -1; + loop[lcnt].prev = ql; + ql = lcnt; + lcnt++; + } + } + flag = false; + while(loop[pl].next >= 0) + { + pl = loop[pl].next; + ql = loop[pl].e; + if(ql == -1) + break; + if(ql == rda) + { + ret = (flag == (edge[rda].set == 'L')); + } + if(edge[ql].st == p) + { + edge[ql].flow += maxflow; + if(!flag && (edge[ql].flow == edge[ql].upf)) + { + edge[ql].set = 'U'; + flag = true; + delete_tree(ql); + }else{ + edge[ql].set = 'T'; + } + p = edge[ql].ed; + }else{ + edge[ql].flow -= maxflow; + if(!flag && (edge[ql].flow == edge[ql].low)) + { + edge[ql].set = 'L'; + flag = true; + delete_tree(ql); + }else{ + edge[ql].set = 'T'; + } + p = edge[ql].st; + } + } + return ret; +} +bool NSMCalc(int &cost) +{ + int rda, i; + M_init(); + calc_pi(0, 0, 0, -1); + rda = (search_ ? calc_dual1() : calc_dual2()); + while(rda >= 0) + { + int j; + insert_tree(rda); + if(augment(rda)) + { + i = edge[rda].st; + j = edge[rda].ed; + calc_pi(i, node[j].pi + edge[rda].cost, node[j].depth + 1, rda); + }else{ + i = edge[rda].ed; + j = edge[rda].st; + calc_pi(i, node[j].pi - edge[rda].cost, node[j].depth + 1, rda); + } + rda = (search_ ? calc_dual1() : calc_dual2()); + } + for(i=ecnt;i 0) + return false; + } + cost = 0; + for(i=0;i= mxv) + continue; + addedge(i + N + 1, j + 1, 0, 1, 0, ecnt); + addedge(i + 1, j + 1, 0, 1, 0, ecnt); + mxv = arr[j].D; + } + } + node[0].d = 2; + node[N * 2 + 2].d = -2; + NSMCalc(ret); + return - ret; +} +bool deal1(){ + int i; + for(i = 1; i <= N; i ++){ + if(arr[i + 1].D < arr[i].D) + return false; + } + printf("%d\n", N); + return true; +} +void domain(){ + int i, ans = 0; + N = ReadInt(); + for(i = 1; i <= N; i ++){ + arr[i].H = ReadInt(); + arr[i].D = ReadInt(); + } + sort(arr + 1, arr + N + 1); + dvn = 0; + for(i = 1; i <= N; i ++){ + dval[dvn ++] = arr[i].D; + } + sort(dval, dval + dvn); + dvn = unique(dval, dval + dvn) - dval; + for(i = 1; i <= N; i ++){ + arr[i].D = lower_bound(dval, dval + dvn, arr[i].D) - dval + 1; + } + ans = calc(); + printf("%d\n", ans); +} +int main(){ + int T = ReadInt(); + while(T --){ + domain(); + } + return 0; +} diff --git a/HDOJ/5407_autoAC.cpp b/HDOJ/5407_autoAC.cpp new file mode 100644 index 0000000..37c188c --- /dev/null +++ b/HDOJ/5407_autoAC.cpp @@ -0,0 +1,47 @@ +#include +using namespace std; +#define prt(k) cerr<<#k" = "< 1) n /= t; + return n==1; +} +ll pmod(ll a, ll n) +{ + ll ret = 1; + for (; n; n>>=1, a=a*a%mod) if (n & 1) + ret = ret * a % mod; + return ret; +} +ll inv(ll a) +{ + return pmod(a, mod - 2); +} +int main() +{ + for (int i=1;i>re; + while (re--) { + scanf("%d", &n); + n++; + ll ans = a[n] * inv(n) % mod; + printf("%I64d\n", ans); + } +} diff --git a/HDOJ/5409_autoAC.cpp b/HDOJ/5409_autoAC.cpp new file mode 100644 index 0000000..84c2db9 --- /dev/null +++ b/HDOJ/5409_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +using namespace std; +const int MAXN = 100005; +struct NODE; +struct EDGE{ + NODE *a, *b; + EDGE *next; + int u; + bool bridge; +}edge[MAXN << 1]; +struct NODE{ + EDGE *head; + NODE *par; + int DFN, low; + int mv; +}node[MAXN]; +int ecnt, dep, n, m; +void Tarjan(NODE *x){ + x->DFN = x->low = ++ dep; + for(EDGE *j = x->head; j; j = j->next){ + NODE *p = j->b; + if(p == x->par) + continue; + if(!p->DFN){ + p->par = x; + Tarjan(p); + } + j->bridge = p->low > x->DFN; + x->low = min(x->low, p->low); + x->mv = max(x->mv, p->mv); + j->u = j->b->mv; + } +} +void addedge(NODE *a, NODE *b, int& ecnt){ + EDGE *j = &edge[ecnt ++]; + j->a = a; + j->b = b; + j->next = a->head; + a->head = j; + j->bridge = false; +} +void domain(){ + int i, u, v; + scanf("%d%d", &n, &m); + ecnt = 0; + for(i = 0; i <= n; i ++){ + node[i].mv = i; + node[i].par = nullptr; + node[i].DFN = 0; + node[i].head = nullptr; + } + for(i = 0; i < m; i ++){ + scanf("%d%d", &u, &v); + addedge(node + u, node + v, ecnt); + addedge(node + v, node + u, ecnt); + } + dep = 0; + Tarjan(node + n); + for(i = 0; i < ecnt; ){ + u = 0; + if(edge[i].bridge) + u = edge[i].u; + i ++; + if(edge[i].bridge) + u = edge[i].u; + i ++; + printf("%d %d\n", u, u > 0 ? u + 1 : 0); + } +} +int main(){ + int T; + scanf("%d", &T); + while(T --) + domain(); + return 0; +} diff --git a/HDOJ/5410_autoAC.cpp b/HDOJ/5410_autoAC.cpp new file mode 100644 index 0000000..64f1d7e --- /dev/null +++ b/HDOJ/5410_autoAC.cpp @@ -0,0 +1,30 @@ +#include +#include +#include +using namespace std; +const int N = 1005; +int w[N], a[N], b[N]; +int dp[N][2005][2]; +int main(){ + int t; scanf("%d", &t); + while (t--){ + int m, n; scanf("%d %d", &m, &n); + for (int i = 1; i <= n; i++){ + scanf("%d %d %d", w + i, a + i, b + i); + } + memset(dp, 0, sizeof dp); + for (int i = 1; i <= n; i++){ + for (int j = 0; j < w[i]; j++){ + dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]); + dp[i][j][1] = 0; + } + for (int j = w[i]; j <= m; j++){ + dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]); + dp[i][j][1] = max(dp[i][j - w[i]][0] + a[i] + b[i], dp[i][j - w[i]][1] + a[i]); + } + } + int ans = max(dp[n][m][0], dp[n][m][1]); + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/5411_autoAC.cpp b/HDOJ/5411_autoAC.cpp new file mode 100644 index 0000000..31c5cc9 --- /dev/null +++ b/HDOJ/5411_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int base = 2015; +const int maxn = 100005; +int T, n, m, k, kk; +struct Matrix +{ + #define size 55 + int m[size][size]; + Matrix() { memset(m, 0, sizeof(m)); } + void operator =(const Matrix&b) { memcpy(m, b.m, sizeof(m)); } + Matrix operator *(const Matrix&b) { + Matrix c; + for (int i = 0; i < size; i++) + for (int j = 0; j < size; j++) + for (int k = 0; k < size; k++) + c.m[i][k] = (c.m[i][k] + m[i][j] * b.m[j][k]) % base; + return c; + } + Matrix get(int x) + { + Matrix a, b = *this; + for (int f = 0; x; x >>= 1) + { + if (x & 1) + if (f) a = a * b; else a = b, f = 1; + b = b * b; + } + return a; + } +}; +int main() +{ + scanf("%d", &T); + while (T--) + { + scanf("%d%d", &n, &m); + Matrix a, b; + for (int i = 1; i <= n + 1; i++) a.m[i][n + 1] = 1; + for (int i = 1; i <= n; i++) + { + scanf("%d", &k); + for (int j = 1; j <= k; j++) + { + scanf("%d", &kk); + a.m[i][kk] = 1; + } + } + for (int i = 1; i <= n + 1; i++) b.m[1][i] = 1; + a = a.get(m); + b = b * a; + if (m == 1) printf("%d\n", n + 1); + else printf("%d\n", b.m[1][n + 1]); + } + return 0; +} diff --git a/HDOJ/5412_autoAC.cpp b/HDOJ/5412_autoAC.cpp new file mode 100644 index 0000000..28fc580 --- /dev/null +++ b/HDOJ/5412_autoAC.cpp @@ -0,0 +1,192 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-9; +const double PI = acos(-1.00); +const double e = exp(1.0); +#define INF 0x3f3f3f3f +#define N 600010 +#define M 100010 +struct treap +{ + int key,wht,count,sz,ch[2]; +} tp[N*15]; +int tree[N<<1]; +int nodecount,root; +int IDX(int l,int r) +{ + return l+r | l!=r; +} +void init() +{ + tp[0].sz=0; + tp[0].wht=-INF; + nodecount=0; + root=0; +} +void update(int x) +{ + tp[x].sz=tp[tp[x].ch[0]].sz+tp[x].count+tp[tp[x].ch[1]].sz; +} +void rotate(int &x,int t) +{ + int y=tp[x].ch[t]; + tp[x].ch[t]=tp[y].ch[!t]; + tp[y].ch[!t]=x; + update(x); + update(y); + x=y; +} +void insert(int &x,int t) +{ + if(! x) + { + x=++nodecount; + tp[x].key=t; + tp[x].wht=rand(); + tp[x].count=1; + tp[x].ch[0]=tp[x].ch[1]=0; + } + else if(tp[x].key==t) tp[x].count++; + else + { + int k=tp[x].keyt) return select(tp[x].ch[0],t); + return tp[x].count+tp[tp[x].ch[0]].sz+select(tp[x].ch[1],t); +} +int a[N],b[N],ord[M][5],lb; +int n,m,tt; +int search(int x) +{ + int l=1,r=b[0],mid; + while (l<=r) + { + mid=(l+r)>>1; + if(b[mid]==x) return mid; + if(b[mid]>1; + if(i<=m) treeinsert(l,m,i,x); + else treeinsert(m+1,r,i,x); +} +void treedel(int l,int r,int i,int x) +{ + erase(tree[IDX(l,r)],x); + if(l==r) return; + int m=(l+r)>>1; + if(i<=m) treedel(l,m,i,x); + else treedel(m+1,r,i,x); +} +int query(int l,int r,int x,int y,int k) +{ + if(l==r) return l; + int m=(l+r)>>1; + int ans=select(tree[IDX(l,m)],y)-select(tree[IDX(l,m)],x); + if(ans>=k) return query(l,m,x,y,k); + return query(m+1,r,x,y,k-ans); +} +int main () +{ + while (~scanf("%d",&n)) + { + b[0]=1; + lb=0; + memset(tree,0,sizeof(tree)); + init(); + for(int i=1; i<=n; i++) + { + scanf("%d",&a[i]); + b[++lb]=a[i]; + } + scanf("%d",&m); + for(int i=1; i<=m; i++) + { + int op; + int x,y,c; + scanf("%d",&op); + if(op == 2) + { + scanf("%d %d %d",&x,&y,&c); + ord[i][1]=1; + ord[i][2]=x; + ord[i][3]=y; + ord[i][4]=c; + } + else + { + scanf("%d %d",&x,&y); + ord[i][1]=2; + ord[i][2]=x; + ord[i][3]=y; + b[++lb]=y; + } + } + sort(b+1,b+1+lb); + for(int i=1; i<=lb; i++) + if(b[i]!=b[b[0]]) b[++b[0]]=b[i]; + for(int i=1; i<=n; i++) + { + a[i]=search(a[i]); + treeinsert(1,b[0],a[i],i); + } + for(int i=1; i<=m; i++) + { + if(ord[i][1]==1) + printf("%d\n",b[query(1,b[0],ord[i][2]-1,ord[i][3],ord[i][4])]); + else + { + treedel(1,b[0],a[ord[i][2]],ord[i][2]); + a[ord[i][2]]=search(ord[i][3]); + treeinsert(1,b[0],a[ord[i][2]],ord[i][2]); + } + } + } + return 0; +} diff --git a/HDOJ/5413_autoAC.cpp b/HDOJ/5413_autoAC.cpp new file mode 100644 index 0000000..131a851 --- /dev/null +++ b/HDOJ/5413_autoAC.cpp @@ -0,0 +1,97 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int MAXN=20000 + 10; +const int INF = numeric_limits::max(); +const LL LL_INF= numeric_limits::max(); +int bit[MAXN][MAXN/32+100]; +struct Edge { + int to,next; + Edge(){} + Edge(int _to,int _next):to(_to),next(_next){} +}e[MAXN*10],e2[MAXN*10]; +int head[MAXN],tot,du[MAXN]; +int head2[MAXN],tot2; +int n,m; +void init(){ + for(int i=1;i<=n;i++)head2[i]=head[i]=-1,du[i]=0; + tot2=0; + tot=0; +} +void AddEdge(int u,int v){ + e[tot]=Edge(v,head[u]); + head[u]=tot++; +} +void AddEdge1(int u,int v){ + e2[tot2]=Edge(v,head2[u]); + head2[u]=tot2++; +} +int que[MAXN],front,rear; +void _or(int posi,int posj){ + for(int i=0;i<=n/32;i++)bit[posi][i]|=bit[posj][i]; +} +void top_bfs(){ + front=rear=0; + memset(bit,0,sizeof(bit)); + for(int i=1;i<=n;i++){ + bit[i][i/32]=(1<<(i%32)); + if(du[i]==0){ + que[front++]=i; + --du[i]; + } + } + while(front!=rear){ + int u=que[rear++]; + for(int i=head[u];~i;i=e[i].next){ + int v=e[i].to; + AddEdge1(v,u); + if(--du[v]==0)que[front++]=v; + } + } +} +template +void Rd(T &tmp){ + char ch; + while((ch=getchar())&&!isdigit(ch)); + tmp=0; + do { + tmp=(tmp<<3)+(tmp<<1)+(ch^48); + }while((ch=getchar())&&isdigit(ch)); + return ; +} +int main() +{ + int T; + Rd(T); + while(T--){ + Rd(n),Rd(m); + init(); + for(int i=0,x,y;i +#include +#include +#include +using namespace std; +const int maxn=100000+100; +char s[maxn]; +char ts[maxn]; +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + scanf("%s%s",s,ts); + int n1=strlen(s); + int n2=strlen(ts); + int cur=0; + for(int i=0;ia1||s[0]!=ts[0]) + printf("No\n"); + else + printf("Yes\n"); + } + else + printf("No\n"); + } + return 0; +} diff --git a/HDOJ/5416_autoAC.cpp b/HDOJ/5416_autoAC.cpp new file mode 100644 index 0000000..d21c7bf --- /dev/null +++ b/HDOJ/5416_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +using namespace std; +const int maxn = 1e6+10; +typedef long long LL; +int dp[maxn]; +int head[maxn],ip; +LL cnt[maxn]; +int n; +struct nod{ + int to,next,w; +}edge[maxn]; +bool vis[maxn]; +void init(){ + ip=0; + memset(head,-1,sizeof(head)); + memset(cnt,0,sizeof(cnt)); + memset(vis,0,sizeof(vis)); +} +void add(int u,int v,int w){ + edge[ip].to=v; + edge[ip].w=w; + edge[ip].next=head[u]; + head[u]=ip++; +} +int mmax; +void dfs(int u,int pre,int val){ + for(int i=head[u];i!=-1;i=edge[i].next){ + int v= edge[i].to; + if(v==pre) continue; + if(edge[i].w^val>mmax) + mmax = edge[i].w^val; + cnt[edge[i].w^val]++; + dfs(v,u,val^edge[i].w); + } +} +int main() +{ + int t,m; + scanf("%d",&t); + while(t--){ + init(); + scanf("%d",&n); + for(int i=0;i +using namespace std; +int main() +{ + int x, y, w, n; + while(cin>>x>>y>>w>>n) + { + n -= 1; + int ans, tmp1, tmp2; + if(w > x) + ans = (x+y)*n; + else + { + tmp1 = n % ((int)(x/w)+1); + tmp2 = n / (x/w+1); + ans = tmp2*(x+y)+w*tmp1; + } + cout< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int MAXN=20; +const int INF = numeric_limits::max(); +int dp[1< +#include +#include +using namespace std ; +#define LL __int64 +LL dp[50100] ; +int a[50100] ; +LL gcd(LL a,LL b) { + return b == 0 ? a : gcd(b,a%b) ; +} +int main() { + int t , n , m ; + int i , l , r ; + LL x , y , temp ; + scanf("%d", &t) ; + while( t-- ) { + scanf("%d %d", &n, &m) ; + memset(dp,0,sizeof(dp)) ; + for(i = 1 ; i <= n ; i++) + scanf("%d", &a[i]) ; + while( m-- ) { + scanf("%d %d", &l, &r) ; + dp[l]++ ; + dp[r+1]-- ; + } + x = 0 ; + y = (LL)n*(n-1)*(n-2)/6 ; + for(i = 1 ; i <= n ; i++) { + dp[i] += dp[i-1] ; + if( dp[i] > 2 ) + x += dp[i]*(dp[i]-1)*(dp[i]-2)/6*a[i] ; + } + if( x == 0 || y == 0 ) { + printf("0\n") ; + continue ; + } + temp = gcd(x,y) ; + x /= temp ; + y /= temp ; + if( y == 1 ) + printf("%I64d\n", x ) ; + else + printf("%I64d/%I64d\n", x, y) ; + } + return 0 ; +} diff --git a/HDOJ/5420_autoAC.cpp b/HDOJ/5420_autoAC.cpp new file mode 100644 index 0000000..e690eb0 --- /dev/null +++ b/HDOJ/5420_autoAC.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int MAXN=100000+1000; +const int MAXM=MAXN*20; +const int INF = numeric_limits::max(); +const LL LL_INF= numeric_limits::max(); +struct Edge { + int to,next; + Edge(){} + Edge(int _to,int _next):to(_to),next(_next){} +}e[MAXM<<3]; +int head[MAXM],tot; +void init(){ + memset(head,-1,sizeof(head)); + tot=0; +} +void AddEdge(int u,int v){ + e[tot]=Edge(v,head[u]); + head[u]=tot++; +} +typedef pair ii; +vector t[MAXN<<2]; +int d[MAXN],L[MAXN],R[MAXN],dep[MAXN],ncnt,rid[MAXN],n,Begin[MAXN<<2]; +void dfs(int u,int d){ + L[u]=++ncnt; + rid[ncnt]=u; + dep[u]=d; + for(int i=head[u];~i;i=e[i].next) + dfs(e[i].to,d+1); + R[u]=ncnt; +} +#define lson L,mid,rt<<1 +#define rson mid+1,R,rt<<1|1 +void build(int L,int R,int rt){ + t[rt].resize(R-L+1); + if(L==R){ + Begin[rt]=n+1; + t[rt][0]=make_pair(dep[rid[L]],rid[L]); + ++n; + AddEdge(n,rid[L]); + return ; + } + int mid=(L+R)>>1; + build(lson);build(rson); + merge(t[rt<<1].begin(),t[rt<<1].end(),t[rt<<1|1].begin(),t[rt<<1|1].end(),t[rt].begin()); + Begin[rt]=n+1; + for(int i=1;i>1; + if(l<=mid)connect(lson,l,r,x,d); + if(r>mid)connect(rson,l,r,x,d); +} +int dfn[MAXM],low[MAXM],sta[MAXM],top,times,bleg[MAXM],cnt[MAXM]; +void tarjan(int u){ + low[u]=dfn[u]=++times; + sta[++top]=u; + for(int i=head[u];~i;i=e[i].next){ + int v=e[i].to; + if(!dfn[v]){ + tarjan(v); + low[u]=min(low[u],low[v]); + } + else if(!bleg[v]) + low[u]=min(low[u],dfn[v]); + } + if(dfn[u]==low[u]){ + bleg[0]++; + cnt[bleg[0]]=0; + do{ + bleg[sta[top]]=bleg[0]; + cnt[bleg[0]]+=(sta[top]<=ncnt); + }while(sta[top--]!=u); + } +} +int main() +{ + int T; + scanf("%d",&T); + while(T--){ + scanf("%d",&n); + init(); + for(int i=2,x;i<=n;i++){ + scanf("%d",&x); + AddEdge(x,i); + } + ncnt=0; + dfs(1,0); + init(); + build(1,ncnt,1); + for(int i=1,x,y;i<=ncnt;i++){ + scanf("%d%d",&x,&y); + connect(1,ncnt,1,L[x],R[x],i,dep[x]+y); + } + memset(dfn,0,sizeof(dfn)); + memset(bleg,0,sizeof(bleg)); + top=times=0; + for(int i=1;i<=n;i++)if(!dfn[i])tarjan(i); + LL ans=0; + for(int i=1;i<=bleg[0];i++){ + ans+=(LL)cnt[i]*(cnt[i]-1)/2; + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/5421_autoAC.cpp b/HDOJ/5421_autoAC.cpp new file mode 100644 index 0000000..d03c105 --- /dev/null +++ b/HDOJ/5421_autoAC.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +using namespace std ; +typedef long long LL ; +#define clr( a , x ) memset ( a , x , sizeof a ) +const int MAXN = 200005 ; +struct Palindromic_Tree { + int nxt[MAXN][26] ; + int fail[MAXN] ; + int len[MAXN] ; + int S[MAXN] , L , R ; + int num[MAXN] ; + int last[2] ; + int p ; + LL tot ; + int newnode ( int l ) { + for ( int i = 0 ; i < 26 ; ++ i ) nxt[p][i] = 0 ; + num[p] = 0 ; + len[p] = l ; + return p ++ ; + } + void init ( int n ) { + p = 0 ; + newnode ( 0 ) ; + newnode ( -1 ) ; + clr ( S , -1 ) ; + L = n ; + R = n - 1 ; + last[0] = last[1] = 1 ; + fail[0] = 1 ; + tot = 0 ; + } + int get_fail ( int v , bool d ) { + if ( d ) while ( S[R - len[v] - 1] != S[R] ) v = fail[v] ; + else while ( S[L + len[v] + 1] != S[L] ) v = fail[v] ; + return v ; + } + void add ( int c , bool d ) { + if ( d ) S[++ R] = c ; + else S[-- L] = c ; + int cur = get_fail ( last[d] , d ) ; + if ( !nxt[cur][c] ) { + int now = newnode ( len[cur] + 2 ) ; + fail[now] = nxt[get_fail ( fail[cur] , d )][c] ; + nxt[cur][c] = now ; + num[now] = num[fail[now]] + 1 ; + } + last[d] = nxt[cur][c] ; + if ( len[last[d]] == R - L + 1 ) last[d ^ 1] = last[d] ; + tot += num[last[d]] ; + } +} ; +Palindromic_ T ; +int n ; +void solve () { + int op ; + char c ; + T.init ( n ) ; + for ( int i = 0 ; i < n ; ++ i ) { + scanf ( "%d" , &op ) ; + if ( op <= 2 ) { + scanf ( " %c" , &c ) ; + T.add ( c - 'a' , op - 1 ) ; + } + if ( op == 3 ) printf ( "%d\n" , T.p - 2 ) ; + if ( op == 4 ) printf ( "%I64d\n" , T.tot ) ; + } +} +int main () { + while ( ~scanf ( "%d" , &n ) ) solve () ; + return 0 ; +} diff --git a/HDOJ/5422_autoAC.cpp b/HDOJ/5422_autoAC.cpp new file mode 100644 index 0000000..d77fc10 --- /dev/null +++ b/HDOJ/5422_autoAC.cpp @@ -0,0 +1,19 @@ +#include +using namespace std; +int main(){ + int n,m,a,b,sign; + while(cin>>n>>m){ + sign=0; + while(m--){ + cin>>a>>b; + if((a==1&&b==n)||(b==1&&a==n)) + sign=1; + } + n=n*(n-1)/2; + if(sign) + cout<<"1 "< +#include +#include +#include +using namespace std; +int s[1005][1005],sum[1005],dis[1005]; +int n; +void dfs(int x,int num){ + int i; + dis[x]=num; + for(i=1;i<=n;i++) + if(s[x][i]&&!dis[i]) + dfs(i,num+1); +} +int main(){ + int i,a,b,ans; + while(scanf("%d",&n)!=EOF){ + memset(s,0,sizeof(s)); + memset(sum,0,sizeof(sum)); + memset(dis,0,sizeof(dis)); + for(i=1;i<=n-1;i++){ + scanf("%d%d",&a,&b); + s[a][b]=s[b][a]=1; + } + dfs(1,1); + for(i=1;i<=n;i++) + sum[dis[i]]++; + ans=0; + for(i=1;i<=n;i++){ + if(sum[i]==1) + ans++; + else{ + if(sum[i+1]==0) + ans=n; + break; + } + } + if(ans==n) + printf("YES\n"); + else + printf("NO\n"); + } + return 0; +} diff --git a/HDOJ/5424_autoAC.cpp b/HDOJ/5424_autoAC.cpp new file mode 100644 index 0000000..4bce6bc --- /dev/null +++ b/HDOJ/5424_autoAC.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +using namespace std; +int n,cnt,x,y,deg[1001]; +bool flag,vis[1001],Map[1001][1001]; +void dfs(int u) +{ + if(cnt==n) {flag=1;return;} + for(int i=1;i<=n&&!flag;++i) + if(!vis[i]&&Map[u][i]) + { + vis[i]=1; + ++cnt; + dfs(i); + --cnt; + vis[i]=0; + } +} +int main() +{ + while(~scanf("%d",&n)) + { + flag=0; + cnt=1; + memset(deg,0,sizeof(deg)); + memset(vis,0,sizeof(vis)); + memset(Map,0,sizeof(Map)); + for(int i=0;i2) {puts("NO");continue;} + vis[s]=1; + dfs(s); + if(flag) puts("YES"); + else puts("NO"); + } + return 0; +} diff --git a/HDOJ/5425_autoAC.cpp b/HDOJ/5425_autoAC.cpp new file mode 100644 index 0000000..aace4e5 --- /dev/null +++ b/HDOJ/5425_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 100005 +vectorvec[MAXN]; +queueq; +int n,d[MAXN]; +inline double f(double a,double b) +{ + return a * b / (a + b); +} +double solve() +{ + double ans = 0; + for(int i = n - 1;i >= max(n - 100,0);i--) + for(int j = n - 1;j > i;j--) + ans += f(d[i],d[j]) / (pow(2.0,n - i) - (n + 1) / pow(2.0,i)); + return ans; +} +int main() +{ + while(scanf("%d",&n) != EOF) + { + for(int i = 0;i <= n;i++)vec[i].clear(); + for(int i = 1;i < n;i++) + { + int u; + scanf("%d",&u); + vec[u - 1].push_back(i); + } + d[0] = 1; + q.push(0); + while(!q.empty()) + { + int u = q.front(); + q.pop(); + for(int i = 0;i < vec[u].size();i++) + { + int v = vec[u][i]; + d[v] = d[u] + 1; + q.push(v); + } + } + sort(d,d + n); + double ans = solve(); + printf("%.6f\n",ans); + } +} diff --git a/HDOJ/5427_autoAC.cpp b/HDOJ/5427_autoAC.cpp new file mode 100644 index 0000000..1d0bab0 --- /dev/null +++ b/HDOJ/5427_autoAC.cpp @@ -0,0 +1,52 @@ +#include +#include +#include +#include +using namespace std; +struct node +{ + char s[110]; + int a; +}p[1000],t; +int T,n; +int main() +{ + while(~scanf("%d",&T)) + { + while(T--) + { + scanf("%d",&n); + getchar(); + for(int i=0;i +#include +#include +using namespace std; +const int maxn=40000; +int T; +int n; +long long a[100],x,cnt; +long long vis[maxn]; +int main() +{ + scanf("%d",&T); + while(T--){ + memset(vis,0,sizeof(vis)); + scanf("%d",&n); + for(int i=0;i1) + vis[cnt++]=x; + } + sort(vis,vis+cnt); + if(cnt<2) + printf("-1\n"); + else + printf("%I64d\n",vis[0]*vis[1]); + } + return 0; +} diff --git a/HDOJ/5429_autoAC.cpp b/HDOJ/5429_autoAC.cpp new file mode 100644 index 0000000..ff34e75 --- /dev/null +++ b/HDOJ/5429_autoAC.cpp @@ -0,0 +1,309 @@ +#include +#include +#include +#include +using namespace std; +#define DIGIT 4 +#define DEPTH 10000 +#define MAX 100 +typedef int bignum_t[MAX+1]; +int read(bignum_ a,istream& is=cin){ + char buf[MAX*DIGIT+1],ch; + int i,j; + memset((void*)a,0,sizeof(bignum_t)); + if (!(is>>buf)) return 0; + for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--) + ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch; + for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j1;a[0]--); + return 1; +} +void write(const bignum_ a,ostream& os=cout){ + int i,j; + for (os<=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++); + return comp(a,c); +} +int comp(const bignum_ a,const int c,const int d,const bignum_ b){ + int i,t=0,O=-DEPTH*2; + if (b[0]-a[0]d;i--){ + t=t*DEPTH+a[i-d]*c-b[i]; + if (t>0) return 1; + if (t0) return 1; + if (t0; +} +void add(bignum_ a,const bignum_ b){ + int i; + for (i=1;i<=b[0];i++) + if ((a[i]+=b[i])>=DEPTH) + a[i]-=DEPTH,a[i+1]++; + if (b[0]>=a[0]) + a[0]=b[0]; + else + for (;a[i]>=DEPTH&&i0); +} +void add(bignum_ a,const int b){ + int i=1; + for (a[1]+=b;a[i]>=DEPTH&&i=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++); +} +void sub(bignum_ a,const bignum_ b){ + int i; + for (i=1;i<=b[0];i++) + if ((a[i]-=b[i])<0) + a[i+1]--,a[i]+=DEPTH; + for (;a[i]<0;a[i]+=DEPTH,i++,a[i]--); + for (;!a[a[0]]&&a[0]>1;a[0]--); +} +void sub(bignum_ a,const int b){ + int i=1; + for (a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++); + for (;!a[a[0]]&&a[0]>1;a[0]--); +} +void sub(bignum_ a,const bignum_ b,const int c,const int d){ + int i,O=b[0]+d; + for (i=1+d;i<=O;i++) + if ((a[i]-=b[i-d]*c)<0) + a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH; + for (;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++); + for (;!a[a[0]]&&a[0]>1;a[0]--); +} +void mul(bignum_ c,const bignum_ a,const bignum_ b){ + int i,j; + memset((void*)c,0,sizeof(bignum_t)); + for (c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++) + for (j=1;j<=b[0];j++) + if ((c[i+j-1]+=a[i]*b[j])>=DEPTH) + c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH; + for (c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--); +} +void mul(bignum_ a,const int b){ + int i; + for (a[1]*=b,i=2;i<=a[0];i++){ + a[i]*=b; + if (a[i-1]>=DEPTH) + a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH; + } + for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++); + for (;!a[a[0]]&&a[0]>1;a[0]--); +} +void mul(bignum_ b,const bignum_ a,const int c,const int d){ + int i; + memset((void*)b,0,sizeof(bignum_t)); + for (b[0]=a[0]+d,i=d+1;i<=b[0];i++) + if ((b[i]+=a[i-d]*c)>=DEPTH) + b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH; + for (;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH); + for (;!b[b[0]]&&b[0]>1;b[0]--); +} +void div(bignum_ c,bignum_ a,const bignum_ b){ + int h,l,m,i; + memset((void*)c,0,sizeof(bignum_t)); + c[0]=(b[0]>1;h>l;m=(h+l+1)>>1) + if (comp(b,m,i-1,a)) h=m-1; + else l=m; + for (;!c[c[0]]&&c[0]>1;c[0]--); + c[0]=c[0]>1?c[0]:1; +} +void div(bignum_ a,const int b,int& c){ + int i; + for (c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--); + for (;!a[a[0]]&&a[0]>1;a[0]--); +} +void sqrt(bignum_ b,bignum_ a){ + int h,l,m,i; + memset((void*)b,0,sizeof(bignum_t)); + for (i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--) + for (h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1) + if (comp(b,m,i-1,a)) h=m-1; + else l=m; + for (;!b[b[0]]&&b[0]>1;b[0]--); + for (i=1;i<=b[0];b[i++]>>=1); +} +int length(const bignum_ a){ + int t,ret; + for (ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++); + return ret>0?ret:1; +} +int digit(const bignum_ a,const int b){ + int i,ret; + for (ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--); + return ret%10; +} +int zeronum(const bignum_ a){ + int ret,t; + for (ret=0;!a[ret+1];ret++); + for (t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++); + return ret; +} +void comp(int* a,const int l,const int h,const int d){ + int i,j,t; + for (i=l;i<=h;i++) + for (t=i,j=2;t>1;j++) + while (!(t%j)) + a[j]+=d,t/=j; +} +void convert(int* a,const int h,bignum_ b){ + int i,j,t=1; + memset(b,0,sizeof(bignum_t)); + for (b[0]=b[1]=1,i=2;i<=h;i++) + if (a[i]) + for (j=a[i];j;t*=i,j--) + if (t*i>DEPTH) + mul(b,t),t=1; + mul(b,t); +} +void combination(bignum_ a,int m,int n){ + int* t=new int[m+1]; + memset((void*)t,0,sizeof(int)*(m+1)); + comp(t,n+1,m,1); + comp(t,2,m-n,-1); + convert(t,m,a); + delete []t; +} +void permutation(bignum_ a,int m,int n){ + int i,t=1; + memset(a,0,sizeof(bignum_t)); + a[0]=a[1]=1; + for (i=m-n+1;i<=m;t*=i++) + if (t*i>DEPTH) + mul(a,t),t=1; + mul(a,t); +} +#define SGN(x) ((x)>0?1:((x)<0?-1:0)) +#define ABS(x) ((x)>0?(x):-(x)) +int read(bignum_ a,int &sgn,istream& is=cin){ + char str[MAX*DIGIT+2],ch,*buf; + int i,j; + memset((void*)a,0,sizeof(bignum_t)); + if (!(is>>str)) return 0; + buf=str,sgn=1; + if (*buf=='-') sgn=-1,buf++; + for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--) + ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch; + for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j1;a[0]--); + if (a[0]==1&&!a[1]) sgn=0; + return 1; +} +struct bignum{ + bignum_t num; + int sgn; +public: +inline bignum(){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=0;} +inline bignum& operator=(const bignum& a){memcpy(num,a.num,sizeof(bignum_t));sgn=a.sgn;return *this;} +inline bignum& operator=(const int a){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=SGN(a);add(num,sgn*a);return *this;}; +inline bignum& operator+=(const bignum& a){if(sgn==a.sgn)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t; + memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=a.sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn;return *this;} +inline bignum& operator+=(const int a){if(sgn*a>0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t; + memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sgn=-sgn;sub(num,t);}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=SGN(a),add(num,ABS(a));return *this;} +inline bignum operator+(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;} +inline bignum operator+(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;} +inline bignum& operator-=(const bignum& a){if(sgn*a.sgn<0)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t; + memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)add(num,a.num),sgn=-a.sgn;return *this;} +inline bignum& operator-=(const int a){if(sgn*a<0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t; + memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=-SGN(a),add(num,ABS(a));return *this;} +inline bignum operator-(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;} +inline bignum operator-(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;} +inline bignum& operator*=(const bignum& a){bignum_ t;mul(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn*=a.sgn;return *this;} +inline bignum& operator*=(const int a){mul(num,ABS(a));sgn*=SGN(a);return *this;} +inline bignum operator*(const bignum& a){bignum ret;mul(ret.num,num,a.num);ret.sgn=sgn*a.sgn;return ret;} +inline bignum operator*(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));mul(ret.num,ABS(a));ret.sgn=sgn*SGN(a);return ret;} +inline bignum& operator/=(const bignum& a){bignum_ t;div(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn;return *this;} +inline bignum& operator/=(const int a){int t;div(num,ABS(a),t);sgn=(num[0]==1&&!num[1])?0:sgn*SGN(a);return *this;} +inline bignum operator/(const bignum& a){bignum ret;bignum_ t;memcpy(t,num,sizeof(bignum_t));div(ret.num,t,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn;return ret;} +inline bignum operator/(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);return ret;} +inline bignum& operator%=(const bignum& a){bignum_ t;div(t,num,a.num);if (num[0]==1&&!num[1])sgn=0;return *this;} +inline int operator%=(const int a){int t;div(num,ABS(a),t);memset(num,0,sizeof(bignum_t));num[0]=1;add(num,t);return t;} +inline bignum operator%(const bignum& a){bignum ret;bignum_ t;memcpy(ret.num,num,sizeof(bignum_t));div(t,ret.num,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn;return ret;} +inline int operator%(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);memset(ret.num,0,sizeof(bignum_t));ret.num[0]=1;add(ret.num,t);return t;} +inline bignum& operator++(){*this+=1;return *this;} +inline bignum& operator--(){*this-=1;return *this;}; +inline int operator>(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);} +inline int operator>(const int a){return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);} +inline int operator>=(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);} +inline int operator>=(const int a){return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);} +inline int operator<(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);} +inline int operator<(const int a){return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);} +inline int operator<=(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);} +inline int operator<=(const int a){return sgn<0?(a<0?comp(num,-a)>=0:1):(sgn>0?(a>0?comp(num,a)<=0:0):a>=0);} +inline int operator==(const bignum& a){return (sgn==a.sgn)?!comp(num,a.num):0;} +inline int operator==(const int a){return (sgn*a>=0)?!comp(num,ABS(a)):0;} +inline int operator!=(const bignum& a){return (sgn==a.sgn)?comp(num,a.num):1;} +inline int operator!=(const int a){return (sgn*a>=0)?comp(num,ABS(a)):1;} +inline int operator[](const int a){return digit(num,a);} +friend inline istream& operator>>(istream& is,bignum& a){read(a.num,a.sgn,is);return is;} +friend inline ostream& operator<<(ostream& os,const bignum& a){if(a.sgn<0)os<<'-';write(a.num,os);return os;} +friend inline bignum sqrt(const bignum& a){bignum ret;bignum_ t;memcpy(t,a.num,sizeof(bignum_t));sqrt(ret.num,t);ret.sgn=ret.num[0]!=1||ret.num[1];return ret;} +friend inline bignum sqrt(const bignum& a,bignum& b){bignum ret;memcpy(b.num,a.num,sizeof(bignum_t));sqrt(ret.num,b.num);ret.sgn=ret.num[0]!=1||ret.num[1];b.sgn=b.num[0]!=1||ret.num[1];return ret;} +inline int length(){return ::length(num);} +inline int zeronum(){return ::zeronum(num);} +inline bignum C(const int m,const int n){combination(num,m,n);sgn=1;return *this;} +inline bignum P(const int m,const int n){permutation(num,m,n);sgn=1;return *this;} +}; +#define N 105 +bignum s[N]; +int main() +{ + int t,n,i,k; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + for(i=k=0;i>s[i]; + if(s[i]==0) + k++; + } + if(k>0&&k +#define LL long long +LL fun(LL m) +{ + LL res=m; + for(LL i=2;i*i<=m;i++) + { + if(m%i==0) + { + res=(res*(i-1))/i; + while(m%i==0) + { + m/=i; + } + } + } + if(m>1) res=(res*(m-1))/m; + return res; +} +int main() +{ + LL n; + int T; + scanf ("%d",&T); + while(T--) + { + scanf("%lld",&n); + printf("%lld\n",fun(n+1)); + } + return 0; +} diff --git a/HDOJ/5431_autoAC.cpp b/HDOJ/5431_autoAC.cpp new file mode 100644 index 0000000..f0681db --- /dev/null +++ b/HDOJ/5431_autoAC.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +using namespace std; +char str[20010]; +int bits[32]; +int save[32][20010]; +int tmp[32]; +int findindex(int i,int key){ + int l=1,r=save[i][0]; + int m,ans=0; + while(l<=r){ + int m=(l+r)/2; + if(save[i][m]<=key){ + ans=m; + l=m+1; + } + else r=m-1; + } + return ans; +} +int main(){ + int kase,now,T,K; + scanf("%d",&kase); + for(int i=1;i<32;i++) bits[i]=(1<bits[i]-save[i][0]){ + K-=(bits[i]-save[i][0]); + continue; + } + int l=0,r=bits[i]-1; + while(l<=r){ + int m=(l+r)>>1; + int pos=findindex(i,m); + if(K>m+1-pos) l=m+1; + else if(K +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair PII; +const int MX = 1e5 + 5; +double A[MX], B[MX]; +int main() { + int T, n; + scanf("%d", &T); + while(T--) { + scanf("%d", &n); + for(int i = 1; i <= n; i++) { + scanf("%lf", &A[i]); + } + for(int i = 1; i <= n; i++) { + scanf("%lf", &B[i]); + } + double L = 0, R = 1000, m; + for(int i = 1; i <= 40; i++) { + m = (L + R) / 2; + double s, sum1 = 0, sum2 = 0; + for(int j = 1; j <= n; j++) { + if(A[j] <= m) s = 0; + else s = B[j] * B[j] * (A[j] - m) * (A[j] - m) * (A[j] - m) / (3.0 * A[j] * A[j]); + sum1 += s; + sum2 += B[j] * B[j] * A[j] / 3.0 - s; + } + if(sum1 < sum2) R = m; + else L = m; + } + printf("%d\n", (int)m); + } + return 0; +} diff --git a/HDOJ/5433_autoAC.cpp b/HDOJ/5433_autoAC.cpp new file mode 100644 index 0000000..832ecb6 --- /dev/null +++ b/HDOJ/5433_autoAC.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 55; +const double eps = 1e-6; +const double inf = 1e20; +const int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; +int N, M, K, Sx, Sy, Ex, Ey; +bool done[maxn][maxn][maxn]; +char G[maxn][maxn]; +double dp[maxn][maxn][maxn]; +struct State { + int x, y, k; + double d; + State(int x = 0, int y = 0, int k = 0, double d = 0): x(x), y(y), k(k), d(d) {} + bool operator < (const State& u) const { return d > u.d; } +}; +void init () { + scanf("%d%d%d", &N, &M, &K); + for (int i = 1; i <= N; i++) + scanf("%s", G[i]+1); + scanf("%d%d%d%d", &Sx, &Sy, &Ex, &Ey); +} +bool Dijkstra () { + for (int i = 1; i <= N; i++) + for (int j = 1; j <= M; j++) + for (int k = 0; k <= K; k++) dp[i][j][k] = inf; + memset(done, false, sizeof(done)); + dp[Sx][Sy][K] = 0; + priority_queue Q; + Q.push(State(Sx, Sy, K, 0)); + while (!Q.empty()) { + State u = Q.top(); + Q.pop(); + int x = u.x, y = u.y, k = u.k; + if (done[x][y][k]) continue; + done[x][y][k] = true; + for (int i = 0; i < 4; i++) { + int p = x + dir[i][0]; + int q = y + dir[i][1]; + int t = k - 1; + if (p <= 0 || p > N || q <= 0 || q > M || t <= 0 || G[p][q] == '#') continue; + double d = 1.0 * abs(G[x][y] - G[p][q]) / k; + if (dp[p][q][t] > dp[x][y][k] + d) { + dp[p][q][t] = dp[x][y][k] + d; + Q.push(State(p, q, t, dp[p][q][t])); + } + } + } + double ans = inf; + for (int i = 1; i <= K; i++) + ans = min(ans, dp[Ex][Ey][i]); + if (fabs(ans-inf) < eps) return false; + printf("%.2lf\n", ans); + return true; +} +int main () { + int cas; + scanf("%d", &cas); + while (cas--) { + init(); + if (!Dijkstra()) printf("No Answer\n"); + } + return 0; +} diff --git a/HDOJ/5434_autoAC.cpp b/HDOJ/5434_autoAC.cpp new file mode 100644 index 0000000..0a1e9b8 --- /dev/null +++ b/HDOJ/5434_autoAC.cpp @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int matMX = 128 + 5; +const int INF = 0x3f3f3f3f; +const LL mod = 1e9 + 7; +struct Mat { + int m, n; + LL S[matMX][matMX]; + Mat(int a, int b) { + m = a; + n = b; + memset(S, 0, sizeof(S)); + } + Mat(int a, int b, LL w[][matMX]) { + m = a; + n = b; + for(int i = 0; i < m; i++) { + for(int j = 0; j < n; j++) { + S[i][j] = w[i][j]; + } + } + } +}; +Mat mat_mul(Mat A, Mat B) { + Mat C(A.m, B.n); + for(int i = 0; i < A.m; i++) { + for(int j = 0; j < B.n; j++) { + for(int k = 0; k < A.n; k++) { + C.S[i][j] = (C.S[i][j] + A.S[i][k] * B.S[k][j]) % mod; + } + } + } + return C; +} +Mat Blank(int m, int n) { + Mat ret(m, n); + for(int i = 0; i < m; i++) { + ret.S[i][i] = 1; + } + return ret; +} +Mat mat_pow(Mat A, LL b) { + Mat ret = Blank(A.m, A.n); + while(b) { + if(b & 1) ret = mat_mul(ret, A); + A = mat_mul(A, A); + b >>= 1; + } + return ret; +} +LL S[matMX][matMX]; +void DFS(int m, int cnt, int x, int y) { + if(cnt == m) { + S[x][y] = 1; + return; + } + DFS(m, cnt + 1, x << 1, y << 1); + DFS(m, cnt + 1, x << 1 | 1, y << 1 | 1); + if(cnt) { + if((x & 1) ^ (y & 1) == 0) { + DFS(m, cnt + 1, x << 1, y << 1 | 1); + DFS(m, cnt + 1, x << 1 | 1, y << 1); + } else if((x & 1) && !(y & 1)) { + DFS(m, cnt + 1, x << 1 | 1, y << 1); + } else { + DFS(m, cnt + 1, x << 1, y << 1 | 1); + } + } else { + DFS(m, cnt + 1, x << 1 | 1, y << 1); + DFS(m, cnt + 1, x << 1, y << 1 | 1); + } +} +int main() { + int m, n; + while(~scanf("%d%d", &n, &m)) { + DFS(m, 0, 0, 0); + Mat A(1 << m, 1 << m, S), B(1 << m, 1); + memset(B.S, 0, sizeof(B.S)); + B.S[0][0] = 1; + Mat ret = mat_mul(mat_pow(A, n), B); + LL ans = 0; + for(int i = 0; i < (1 << m); i++) { + ans += ret.S[i][0]; + ans %= mod; + } + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5435_autoAC.cpp b/HDOJ/5435_autoAC.cpp new file mode 100644 index 0000000..c482131 --- /dev/null +++ b/HDOJ/5435_autoAC.cpp @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define getmid(l,r) ((l) + ((r) - (l)) / 2) +#define MEM(a,b) memset(a,b,sizeof(a)) +#define MP(a,b) make_pair(a,b) +#define PB push_back +typedef long long ll; +typedef pair pii; +const double eps = 1e-8; +const int INF = (1 << 30) - 1; +const int MAXN = 100010; +const ll mod = 1e9 + 7; +int T,LA,LB; +char A[MAXN],B[MAXN]; +int dp[100010][16]; +int Solve(char *s,int L,int p,int f,int xsum){ + if(p > L) return xsum; + if(f){ + int len = L - p + 1; + int res = 0; + for(int i = 0; i < 16; ++i) + res = (res + 1ll * (xsum ^ i) * dp[len][i]) % mod; + return res; + } + int top = s[p] - '0'; + int res = 0; + for(int i = 0; i <= top; ++i) + res = (res + 1ll * Solve(s,L,p + 1,f | (i < top),xsum ^ i)) % mod; + return res; +} +void Pre(){ + dp[0][0] = 1; + for(int i = 1; i < 100010; ++i) + for(int j = 0; j < 16; ++j) + for(int k = 0; k < 10; ++k) + dp[i][j] = (dp[i][j] + 1ll * dp[i - 1][j ^ k]) % mod; +} +int main(){ + Pre(); + scanf("%d",&T); + for(int tt = 1; tt <= T; ++tt){ + scanf("%s%s",A + 1,B + 1); + LA = strlen(A + 1); + LB = strlen(B + 1); + int tmp = 0; + for(int i = 1; i <= LA; ++i) tmp ^= (A[i] - '0'); + int ansA = Solve(A,LA,1,0,0); + int ansB = Solve(B,LB,1,0,0); + printf("Case #%d: %d\n",tt,(int) + (((1ll * ansB - ansA + tmp) % mod + mod) % mod)); + } + return 0; +} diff --git a/HDOJ/5437_autoAC.cpp b/HDOJ/5437_autoAC.cpp new file mode 100644 index 0000000..1ee4fc9 --- /dev/null +++ b/HDOJ/5437_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define maxn 150005 +using namespace std; +struct node +{ + char name[205]; + int v, tp; + friend bool operator <(node a,node b) + { + if(a.v == b.v) return a.tp > b.tp; + return a.v < b.v; + } +}; +node fri[maxn]; +struct node1 +{ + int t, r; +}ask[maxn]; +bool cmp(node1 a, node1 b) +{ + return a.t < b.t; +} +int put[maxn], wen[105]; +int main() +{ + int t, k, m, p, i, j, ok, now; + scanf("%d", &t); + while(t--) + { + scanf("%d %d %d", &k, &m, &p); + for(i = 0;i < k;i++) + { + scanf("%s %d",fri[i].name, &fri[i].v); + fri[i].tp = i; + } + ask[0].t = -1; + for(i = 0;i < m;i++) + scanf("%d %d", &ask[i].t, &ask[i].r); + for(i = 0;i < p;i++) + scanf("%d", &wen[i]); + priority_queueq; + sort(ask, ask + m, cmp); + now = 0; + ok = 0; + for(i = 1;i <= k;i++) + { + q.push(fri[i - 1]); + if(i == ask[now].t) + { + for(j = 1;j <= ask[now].r&&(!q.empty());j++) + { + node x = q.top(); + q.pop(); + put[ok++] = x.tp; + } + now++; + } + } + while(!q.empty()) + { + node x = q.top(); + q.pop(); + put[ok++] = x.tp; + } + for(i = 0;i < p;i++) + printf("%s%c", fri[put[wen[i] - 1]].name, i==p-1?'\n':' '); + } +} diff --git a/HDOJ/5438_autoAC.cpp b/HDOJ/5438_autoAC.cpp new file mode 100644 index 0000000..cfa6200 --- /dev/null +++ b/HDOJ/5438_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define pr(x) cout << #x << " = " << x << " " +#define prln(x) cout << #x << " = " << x << endl +const int N = 1e4 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7; +const int M = 1e5 + 10; +int n, m; +int deg[N], val[N]; +vector G[N]; +bool vis[N]; +void dfs(int u, int &cnt, long long& sum) { + sum += val[u]; + ++cnt; + vis[u] = true; + for(int i = 0; i < G[u].size(); ++i) { + int v = G[u][i]; + if(vis[v]) continue; + dfs(v, cnt, sum); + } +} +int main() { + ios_base::sync_with_stdio(0); + int t; scanf("%d", &t); + while(t--) { + scanf("%d%d", &n, &m); + for(int i = 1; i <= n; ++i) { + scanf("%d", val + i); + G[i].clear(); + vis[i] = false; + deg[i] = 0; + } + for(int i = 1; i <= m; ++i) { + int u, v; scanf("%d%d", &u, &v); + G[u].push_back(v); + G[v].push_back(u); + ++deg[u], ++deg[v]; + } + queue q; + for(int i = 1; i <= n; ++i) + if(deg[i] < 2) q.push(i); + while(q.size()) { + int u = q.front(); q.pop(); + deg[u] = 0; vis[u] = true; + for(int i = 0; i < G[u].size(); ++i) { + int v = G[u][i]; + if(--deg[v] < 2 && !vis[v]) q.push(v); + } + } + long long ans = 0; + for(int i = 1; i <= n; ++i) { + if(vis[i]) continue; + int cnt = 0; long long sum = 0; + dfs(i, cnt, sum); + if(cnt & 1) ans += sum; + } + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5439_autoAC.cpp b/HDOJ/5439_autoAC.cpp new file mode 100644 index 0000000..224e2a2 --- /dev/null +++ b/HDOJ/5439_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int MOD = (int)1e9+7; +const int INF = (int)1e9; +const int MAXN = 438744; +int a[MAXN+5]; +int b[MAXN+5]; +int sum[MAXN+5]; +int dp[MAXN+5]; +int pre[MAXN+5]; +int sz,val; +int add(int x,int y){ + x+=y; + if(x>=MOD)x-=MOD; + return x; +} +int po(int x,int n){ + int ans=1; + int temp=x; + while(n){ + if(n&1)ans=(ll)ans*temp%MOD; + temp=(ll)temp*temp%MOD; + n>>=1; + } + return ans; +} +int main() +{ + val=po(2,MOD-2); + a[1]=1; + a[2]=2; + a[3]=2; + int sz=3; + for(int i=3;;i++){ + int cnt=a[i]; + while(cnt){ + a[++sz]=i; + cnt--; + if(sz>=MAXN)break; + } + if(sz>=MAXN)break; + } + for(int i=1;i<=MAXN;i++){ + sum[i]=sum[i-1]+a[i]; + if(sum[i]>=INF)break; + } + for(int i=1;i<=MAXN;i++){ + dp[i]=add(dp[i-1],(ll)( add(add(add(pre[i-1],1),pre[i-1]),a[i]) )*a[i]%MOD*i%MOD*val%MOD); + pre[i]=add(pre[i-1],a[i]); + } + int t;scanf("%d",&t); + while(t--){ + int n;scanf("%d",&n); + int l=1,r=MAXN; + int pos; + while(l<=r){ + int mid=l+r>>1; + if(n<=sum[mid]){ + pos=mid; + r=mid-1; + } + else l=mid+1; + } + int x=n-sum[pos-1]; + int ans=add(dp[pos-1],(ll)( add(add(add(pre[pos-1],1),pre[pos-1]),x) )*x%MOD*pos%MOD*val%MOD); + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/5440_autoAC.cpp b/HDOJ/5440_autoAC.cpp new file mode 100644 index 0000000..cde09bb --- /dev/null +++ b/HDOJ/5440_autoAC.cpp @@ -0,0 +1,145 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxn = 1 * 1e5 + 5; +ll S; +int N, M, L[10], X[10], head, rear, ans; +map C; +set T; +struct State { + ll s; + int f, c; + State(ll s = 0, int f = 0, int c = 0): s(s), f(f), c(c) {} +}Q[maxn], cur; +inline ll idx(int* c) { + ll ret = 0; + for (int i = 0; i < 12; i++) + ret = ret * (N+1) + c[i]; + return ret; +} +inline void reidx(ll s, int* c) { + for (int i = 11; i >= 0; i--) { + c[i] = s % (N+1); + s /= (N+1); + } +} +void init () { + C.clear(); + T.clear(); + scanf("%d%d", &N, &M); + int x, cnt[15]; + memset(cnt, 0, sizeof(cnt)); + for (int i = 1; i <= N; i++) { + scanf("%d", &x); + if (x == 12) x = 0; + cnt[x]++; + } + S = idx(cnt); + for (int i = 0; i < M; i++) + scanf("%d%d", &L[i], &X[i]); +} +bool dfs1 (int d, int* c, int* t, int n, int m, int v) { + if (d > 12 || n > m) return false; + if (n == 0 && m == 0) { + ll tmp = idx(t); + if (tmp == S) { + ans = cur.c + 1; + return true; + } + if (!C.count(tmp)) { + C[tmp] = cur.c + 1; + if (cur.c < 4) Q[rear++] = State(tmp, v, cur.c+1); + } + return false; + } + for (int i = min(c[d], n); i >= 0; i--) { + if (n-i > m-c[d]) break; + t[(d-X[v]+12)%12] += i; + t[d] += (c[d] - i); + if (dfs1(d+1, c, t, n-i, m-c[d], v)) return true; + t[(d-X[v]+12)%12] -= i; + t[d] -= (c[d] - i); + } + return false; +} +bool dfs2 (int d, int* c, int* t, int n, int m, int v) { + if (d > 12 || n > m) return false; + if (n == 0 && m == 0) { + ll tmp = idx(t); + if (C.count(tmp)) { + ans = C[tmp] + cur.c + 1; + return true; + } + if (!T.count(tmp) && cur.c < 2) { + T.insert(tmp); + Q[rear++] = State(tmp, v, cur.c+1); + } + return false; + } + for (int i = min(c[d], n); i >= 0; i--) { + if (n-i > m-c[d]) break; + t[(d+X[v]+12)%12] += i; + t[d] += (c[d] - i); + if (dfs2(d+1, c, t, n-i, m-c[d], v)) return true; + t[(d+X[v]+12)%12] -= i; + t[d] -= (c[d] - i); + } + return false; +} +int bfs() { + int cnt[15], pos[15]; + memset(cnt, 0, sizeof(cnt)); + cnt[0] = N; + ll k = idx(cnt); + if (S == k) return 0; + C[k] = 0; + head = rear = 0; + for (int i = 0; i < M; i++) { + int x = (-X[i] + 12) % 12; + cnt[x] += L[i]; + cnt[0] -= L[i]; + ll tmp = idx(cnt); + if (!C.count(tmp)) { + if (tmp == S) return 1; + Q[rear++] = State(tmp, i, 1); + C[tmp] = 1; + } + cnt[x] -= L[i]; + cnt[0] += L[i]; + } + while (head < rear) { + cur = Q[head++]; + reidx(cur.s, cnt); + for (int i = M-1; i >= cur.f; i--) { + memset(pos, 0, sizeof(pos)); + if (dfs1(0, cnt, pos, L[i], N, i)) + return ans; + } + } + head = rear = 0; + Q[rear++] = State(S, 0, 0); + while (head < rear) { + cur = Q[head++]; + reidx(cur.s, cnt); + for (int i = M-1; i >= cur.f; i--) { + memset(pos, 0, sizeof(pos)); + if (dfs2(0, cnt, pos, L[i], N, i)) return ans; + } + } + return -1; +} +int main () { + int cas; + scanf("%d", &cas); + while (cas--) { + init(); + printf("%d\n", bfs()); + } + return 0; +} diff --git a/HDOJ/5441_autoAC.cpp b/HDOJ/5441_autoAC.cpp new file mode 100644 index 0000000..7b698e0 --- /dev/null +++ b/HDOJ/5441_autoAC.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#define MAX 20007 +using namespace std; +int fa[MAX],num[MAX],t,n,m,q,pp[MAX]; +struct Query +{ + int x,id; + bool operator < ( const Query& a )const + { + return x < a.x; + } +}a[MAX]; +struct Edge +{ + int u,v,w; + bool operator < ( const Edge& a ) const + { + return w < a.w; + } +}e[MAX*5]; +void init ( ) +{ + for ( int i = 1 ; i <= n ; i++ ) + { + num[i] = 1; + fa[i] = i; + } +} +int _find ( int x ) +{ + return fa[x] == x? x : fa[x] = _find ( fa[x] ); +} +void _union ( int x , int y ) +{ + x = _find ( x ); + y = _find ( y ); + if ( y < x ) swap ( x , y ); + fa[y] = x; + num[x] += num[y]; +} +int main ( ) +{ + scanf ( "%d" ,&t ); + while ( t-- ) + { + int ans = 0; + scanf ( "%d%d%d" , &n , &m , &q ); + init ( ); + for ( int i = 0 ; i < m ; i++ ) + scanf ( "%d%d%d" , &e[i].u , &e[i].v , &e[i].w ); + sort ( e , e+m ); + int j = 0; + for ( int i = 0 ; i < q ; i++ ) + { + a[i].id = i; + scanf ( "%d" , &a[i].x ); + } + sort ( a , a+q ); + for ( int i = 0 ; i < q ; i++ ) + { + while ( j < m && e[j].w <= a[i].x ) + { + int u = _find ( e[j].u ); + int v = _find ( e[j].v ); + j++; + if ( u == v ) continue; + ans += (num[u]+num[v])*(num[u]+num[v]-1)-num[u]*(num[u]-1) - num[v]*(num[v]-1); + _union ( u , v ); + } + pp[a[i].id] = ans; + } + for ( int i = 0 ; i < q ; i++ ) + printf ( "%d\n" , pp[i] ); + } +} diff --git a/HDOJ/5442_autoAC.cpp b/HDOJ/5442_autoAC.cpp new file mode 100644 index 0000000..e9981c5 --- /dev/null +++ b/HDOJ/5442_autoAC.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include +using namespace std; +#define maxn 200007 +int wwa[maxn],wwb[maxn],wwv[maxn],wws[maxn]; +int cmp(int *r,int a,int b,int l){ + return r[a]==r[b]&&r[a+l]==r[b+l]; +} +void da(int *r,int *sufix,int n,int m){ + int i,j,p,*x=wwa,*y=wwb,*t; + for(i=0;i=0;i--)sufix[--wws[x[i]]]=i; + for(j=1,p=1;p=j) + y[p++]=sufix[i]-j; + for(i=0;i=0;i--) + sufix[--wws[wwv[i]]]=y[i]; + for(t=x,x=y,y=t,p=1,x[sufix[0]]=0,i=1;i 1; i--){ + if(height[i+1] < n) break; + if(sufix[i]>=n&&sufix[i]<=n*2) continue; + if(sufix[i]>=n*3+1)continue; + ans[cnt++].p = sufix[i]; + } + for(int i = 0;i < cnt; i++){ + if(ans[i].p > 2*n){ + ans[i].c =1; + ans[i].p = n-(ans[i].p-2*n-1); + } + else { + ans[i].p++; + ans[i].c = 0; + } + } + sort(ans,ans+cnt,comp); + printf("%d %d\n",ans[0].p,ans[0].c); + } + return 0; +} diff --git a/HDOJ/5443_autoAC.cpp b/HDOJ/5443_autoAC.cpp new file mode 100644 index 0000000..60bfa53 --- /dev/null +++ b/HDOJ/5443_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define pr(x) cout << #x << " = " << x << " " +#define prln(x) cout << #x << " = " << x << endl +const int N = 1e3 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7; +int n, q, dp[2][N][20]; +int RMQ(int l, int r) { + int k = 31 - __builtin_clz(r - l + 1); + int Max = max(dp[1][l][k], dp[1][r - (1 << k) + 1][k]); + return Max; +} +int main() { + int t; scanf("%d", &t); + while(t--) { + scanf("%d", &n); + for(int i = 1; i <= n; ++i) { + scanf("%d", &dp[0][i][0]); + dp[1][i][0] = dp[0][i][0]; + } + for(int j = 1; (1 << j) <= n; ++j) { + for(int i = 1; i + (1 << j) - 1 <= n; ++i) { + dp[0][i][j] = min(dp[0][i][j - 1], + dp[0][i + (1 << j - 1)][j - 1]); + dp[1][i][j] = max(dp[1][i][j - 1], + dp[1][i + (1 << j - 1)][j - 1]); + } + } + scanf("%d", &q); + while(q--) { + int x, y; scanf("%d%d", &x, &y); + printf("%d\n", RMQ(x, y)); + } + } + return 0; +} diff --git a/HDOJ/5444_autoAC.cpp b/HDOJ/5444_autoAC.cpp new file mode 100644 index 0000000..58ec5fb --- /dev/null +++ b/HDOJ/5444_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +using namespace std; +const int maxn = 1100; +struct tree{ + int v, l, r, f; + tree(){} + tree(int v, int l, int r, int f):v(v), l(l), r(r), f(f){} +} t[maxn<<2]; +int T, n; +int pt, sz; +int st[maxn]; +int a[maxn]; +int ps[maxn]; +bool v[maxn]; +void work(int x){ + int pos = 0, ed = ps[x]; + while(1){ + if (pt > ed) break; + v[a[pt]] = true; + if (t[pos].v > a[pt]){ + if (t[pos].r == -1){ + st[a[pt]] = sz; + t[sz] = tree(a[pt++], -1, -1, pos); + t[pos].r = sz; + pos = sz++; + } + else pos = t[pos].r; + } + else{ + if (t[pos].l == -1){ + st[a[pt]] = sz; + t[sz] = tree(a[pt++], -1, -1, pos); + t[pos].l = sz; + pos = sz++; + } + else pos = t[pos].l; + } + } +} +char s[1100]; +void output(int x){ + int len = 0, px; + while(1){ + px = x; + x = t[x].f; + if (x == -1) break; + if (t[x].l == px) s[len++] = 'W'; + else s[len++] = 'E'; + } + for (int i = 0, j = len-1; i < j; i++, j--) + swap(s[i], s[j]); + s[len] = 0; + printf("%s\n", s); +} +int main() +{ + scanf("%d", &T); + while(T--){ + scanf("%d", &n); + for (int i = 0; i < n; i++){ + v[i+1] = false; + scanf("%d", &a[i]); + ps[a[i]] = i; + } + sz = 0, pt = 1; + t[sz++] = tree(a[0], -1, -1, -1); + v[a[0]] = true; + for (int i = 1; i <= n; i++) + if (!v[i]){ work(i); } + int q, qq; + scanf("%d", &q); + for (int i = 0; i < q; i++){ + scanf("%d", &qq); + output(st[qq]); + } + } + return 0; +} diff --git a/HDOJ/5445_autoAC.cpp b/HDOJ/5445_autoAC.cpp new file mode 100644 index 0000000..0053e56 --- /dev/null +++ b/HDOJ/5445_autoAC.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +typedef unsigned long long ull; +#define ff(i, n) for(int i=0,END=(n);i=END;i--) +#define travel(e, u) for(int e=first[u], v=vv[first[u]]; ~e; e=nxt[e]) +#define mid ((l+r)/2) +#define bit(n) (1ll<<(n)) +#define clr(a, b) memset(a, b, sizeof(a)) +#define debug(x) cout << #x << " = " << x << endl; +#define ls (rt << 1) +#define rs (ls | 1) +#define lson l, m, ls +#define rson m + 1, r, rs +void work(); +int main() { + work(); + return 0; +} +const int maxn = 222; +const int maxv = 5e4 + 5 + maxn; +const int inf = 0x3f3f3f3f; +int n, m, p; +int dp[maxv]; +void zero_one_pack(int v, int c, int V) { + dff(i, V, v) { + dp[i] = min(dp[i], dp[i - v] + c); + } +} +void zero_one_pack2(int v, int c, int V) { + dff(i, V, v) { + dp[i] = max(dp[i], dp[i - v] + c); + } +} +void multi_pack(int v, int c, int num, int V, bool flag = true) { + int k = 1; + while (num) { + if (flag) + zero_one_pack(v * k, c * k, V); + else + zero_one_pack2(v * k, c * k, V); + num -= k; + k += k; + if (k > num) k = num; + } +} +void input() { + scanf("%d%d%d", &n, &m, &p); + clr(dp, inf); dp[0] = 0; + ff (i, n) { + int v, c, num; + scanf("%d%d%d", &v, &c, &num); + multi_pack(v, c, num, p + 100); + } + int V = *min_element(dp + p, dp + p + 100); + clr(dp, 0); + ff (i, m) { + int v, c, num; + scanf("%d%d%d", &v, &c, &num); + multi_pack(c, v, num, 50000, false); + } + int ans = inf; + dff(i, 50000, 0) if (dp[i] >= V) { + ans = min(ans, i); + } + if (ans == inf) { + puts("TAT"); + } else { + printf("%d\n", ans); + } +} +void work() { + int T; scanf("%d", &T); + fff(cas, 1, T) { + input(); + } +} diff --git a/HDOJ/5446_autoAC.cpp b/HDOJ/5446_autoAC.cpp new file mode 100644 index 0000000..d432a73 --- /dev/null +++ b/HDOJ/5446_autoAC.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +using namespace std; +#define debug 0 +const int maxn = 101000; +typedef long long ll; +ll A[maxn], inv[maxn]; +int res[20]; +int p[20]; +void gcd(ll a, ll b, ll d, ll& x, ll& y){ + if (!b) { d = a; x = 1; y = 0; } + else{ gcd(b, a%b, d, y, x); y -= x*(a/b); } +} +int cal(long long n, long long m, int p){ + A[0] = A[1] = 1; + inv[0] = inv[1] = 1; + for (int i = 2; i <= p; i++){ + inv[i] = (long long)(p - p/i) * inv[p % i] % p; + A[i] = A[i-1] * i % p; + } + for (int i = 2; i < p; i++){ + inv[i] = inv[i] * inv[i-1] % p; + } + if (debug){ + for (int i = 0; i < p; i++){ + assert(inv[i] * A[i] % p == 1); + printf("%lld %lld\n", inv[i], A[i]); + } + } + int ret = 1; + while(n&&m){ + int a = n % p, b = m % p; + if (a < b) return 0; + n /= p, m /= p; + ret = (long long)ret * A[a] % p * inv[b] % p * inv[a-b] % p; + } + return ret; +} +ll mul(ll a, ll b, ll p){ + ll ret = 0; + for (; a; a>>=1){ + if (a&1){ + ret += b; + if (ret >= p) ret -= p; + } + b <<= 1; + if (b >= p) b -= p; + } + return ret; +} +ll crt(int n, int* a, int *m){ + ll M = 1, d, y, x = 0; + for (int i = 0; i < n; i++) M *= m[i]; + for (int i = 0; i < n; i++){ + ll w = M / m[i]; + gcd(m[i], w, d, d, y); + int sign; + if (y < 0) sign = -1; + else sign = 1; + x = (x + mul(y*sign, w*a[i]%M, M) * sign) % M; + } + return (x + M) % M; +} +int T; +int main() +{ + scanf("%d", &T); + while(T--){ + ll n, m; int k; + scanf("%I64d %I64d %d", &n, &m, &k); + for (int i = 0; i < k; i++){ + scanf("%d", &p[i]); + res[i] = cal(n, m, p[i]); + } + long long ans = crt(k, res, p); + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5448_autoAC.cpp b/HDOJ/5448_autoAC.cpp new file mode 100644 index 0000000..409793a --- /dev/null +++ b/HDOJ/5448_autoAC.cpp @@ -0,0 +1,49 @@ +#include +typedef long long LL; +const int maxn = 100010, mod = 1000000007, inv2 = 500000004; +int t, n, pw1[maxn], pw2[maxn], x, y, pre1x, pre1y, pre2x, pre2y, ans; +int mod_add(int x, int y) +{ + x += y; + if(x >= mod) + x -= mod; + return x; +} +int mod_sub(int x, int y) +{ + x -= y; + if(x < 0) + x += mod; + return x; +} +int det(int x1, int y1, int x2, int y2) +{ + return mod_sub((LL)x1 * y2 % mod, (LL)x2 * y1 % mod); +} +int main() +{ + scanf("%d", &t); + pw1[0] = 1; + for(int i = 1; i < maxn; ++i) + pw1[i] = (LL)pw1[i - 1] * 2 % mod; + pw2[0] = 1; + for(int i = 1; i < maxn; ++i) + pw2[i] = (LL)pw2[i - 1] * inv2 % mod; + while(t--) + { + scanf("%d", &n); + pre1x = pre1y = pre2x = pre2y = ans = 0; + for(int i = 1; i <= n; ++i) + { + scanf("%d%d", &x, &y); + ans = mod_add(ans, (LL)pw1[i - 1] * det(x, y, pre2x, pre2y) % mod); + ans = mod_add(ans, (LL)(i == n ? inv2 : pw1[n - i - 1]) * det(pre1x, pre1y, x, y) % mod); + pre1x = mod_add(pre1x, (LL)x * pw1[i] % mod); + pre1y = mod_add(pre1y, (LL)y * pw1[i] % mod); + pre2x = mod_add(pre2x, (LL)x * pw2[i] % mod); + pre2y = mod_add(pre2y, (LL)y * pw2[i] % mod); + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/5449_autoAC.cpp b/HDOJ/5449_autoAC.cpp new file mode 100644 index 0000000..a50e668 --- /dev/null +++ b/HDOJ/5449_autoAC.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxn = 50005; +int N, E, first[maxn], jump[maxn<<1], linker[maxn<<1]; +ll sz[maxn], up[maxn], dn[maxn], f[20][maxn], dep[maxn]; +void addEdge(int u, int v) { + jump[E] = first[u]; + linker[E] = v; + first[u] = E++; +} +void dfs (int u, int far, int d) { + sz[u] = 1; + dep[u] = d; + f[0][u] = far; + for (int i = first[u]; i + 1; i = jump[i]) { + int v = linker[i]; + if (v == far) continue; + dfs(v, u, d + 1); + sz[u] += sz[v]; + } +} +void dfs (int u) { + if (f[0][u] != -1) { + up[u] = up[f[0][u]] + 2 * sz[u] - 1; + dn[u] = dn[f[0][u]] + 2 * (N-sz[u]) - 1; + } else + up[u] = dn[u] = 0; + for (int i = first[u]; i + 1; i = jump[i]) { + int v = linker[i]; + if (v == f[0][u]) continue; + dfs(v); + } +} +int lca(int u, int v) { + if (dep[u] < dep[v]) swap(u, v); + int d = dep[u] - dep[v]; + for (int i = 0; i < 20; i++) if ((1<= 0; i--) { + if (f[i][u] != f[i][v]) { + u = f[i][u]; + v = f[i][v]; + } + } + return f[0][u]; +} +void init () { + E = 0; + memset(first, -1, sizeof(first)); + int u, v; + scanf("%d", &N); + for (int i = 1; i < N; i++) { + scanf("%d%d", &u, &v); + addEdge(u, v); + addEdge(v, u); + } + dfs(0, -1, 0); + dfs(0); + for (int k = 1; k < 20; k++) { + for (int i = 0; i < N; i++) + f[k][i] = f[k-1][f[k-1][i]]; + } +} +ll get (int u, int v) { + int l = lca(u, v); + return up[u] - up[l] + dn[v] - dn[l]; +} +void solve () { + int q, p, u, v; + scanf("%d", &q); + while (q--) { + ll ans = 0; + scanf("%d%d", &p, &u); + while (p--) { + scanf("%d", &v); + ans += get(u, v); + u = v; + } + printf("%lld.0000\n", ans); + } +} +int main () { + int cas; + scanf("%d", &cas); + while (cas--) { + init(); + solve(); + if (cas) printf("\n"); + } + return 0; +} diff --git a/HDOJ/5450_autoAC.cpp b/HDOJ/5450_autoAC.cpp new file mode 100644 index 0000000..d7ac36c --- /dev/null +++ b/HDOJ/5450_autoAC.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +using namespace std; +const int maxn = 105; +const int maxm = 15; +const int maxs = 200000; +const int mod = 10007; +int N, P, dp[maxn][maxs]; +bool exist[maxn]; +int encode (int* c, int n) { + int ret = 0; + for (int i = 0; i < n; i++) + ret = ret * 3 + c[i]; + return ret; +} +void decode(int* c, int n, int s) { + for (int i = n-1; i >= 0; i--) { + c[i] = s % 3; + s /= 3; + } +} +void move(int* c, int n) { + for (int i = n; i > 0; i--) + c[i] = c[i-1]; + c[0] = 0; +} +void init () { + scanf("%d%d", &N, &P); + memset(exist, false, sizeof(exist)); + int k, x; + scanf("%d", &k); + for (int i = 0; i < k; i++) { + scanf("%d", &x); + exist[x] = true; + } +} +void add(int& u, int v) { u = (u + v) % mod; } +int solve () { + int n = P + 2, cur[maxm], nxt[maxm], idx[3]; + idx[0] = 1, idx[1] = P, idx[2] = P + 2; + memset(dp, 0, sizeof(dp)); + for (int i = 0; i < n; i++) cur[i] = 2; + int e = encode(cur, n); + dp[0][e] = 1; + for (int i = 0; i < N; i++) { + for (int s = 0; s <= e; s++) { + if (dp[i][s] == 0) continue; + decode(cur, n, s); + memcpy(nxt, cur, sizeof(cur)); + move(nxt, n); + if (exist[i+1]) { + nxt[0] = 2; + if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]); + continue; + } + if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]); + nxt[0] = 1; + for (int j = 0; j < 3; j++) { + int& v = nxt[idx[j]]; + if (v < 2) { + v++; + if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]); + v--; + } + } + nxt[0] = 2; + for (int j = 0; j < 3; j++) { + for (int k = j+1; k < 3; k++) { + int& u = nxt[idx[j]]; + int& v = nxt[idx[k]]; + if (u < 2 && v < 2) { + u++, v++; + if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]); + u--, v--; + } + } + } + } + } + return dp[N][e]; +} +int main () { + int cas; + scanf("%d", &cas); + for (int kcas = 1; kcas <= cas; kcas++) { + init(); + printf("Case #%d: %d\n", kcas, solve()); + } + return 0; +} diff --git a/HDOJ/5451_autoAC.cpp b/HDOJ/5451_autoAC.cpp new file mode 100644 index 0000000..d7d1c84 --- /dev/null +++ b/HDOJ/5451_autoAC.cpp @@ -0,0 +1,74 @@ +#include +#include +#include +#include +#define LL long long +#define FOR(i,x,y) for(int i = x;i < y;i ++) +#define IFOR(i,x,y) for(int i = x;i > y;i --) +#define N 2 +int MOD; +LL p; +struct Matrix{ + LL mat[N][N]; + Matrix operator *(const Matrix& a) const{ + Matrix c; + memset(c.mat,0,sizeof(c.mat)); + for(int i=0;i>1; + } + return c; + } +}; +Matrix ss; +LL quickpow(LL a,LL n,int m){ + LL ret = 1; + while(n){ + if(n&1) ret = (ret*a)%m; + a = (a*a)%m; + n >>= 1; + } + return ret; +} +int main(){ + int T,tCase = 0; + scanf("%d",&T); + ss.mat[0][0] = 10; ss.mat[0][1] = -1; ss.mat[1][0] = 1; ss.mat[1][1] = 0; + while(T--){ + printf("Case #%d: ",++tCase); + LL x; + scanf("%I64d%d",&x,&MOD); + p = (MOD-1)*(MOD+1); + LL r = quickpow(2,x,p); + Matrix st; + st.mat[0][0] = 10; st.mat[0][1] = -1; st.mat[1][0] = 1; st.mat[1][1] = 0; + st = st^r; + LL aaaa = (((st.mat[0][0]*10)%MOD+MOD)%MOD + ((st.mat[0][1]*2)%MOD+MOD)%MOD)%MOD; + if(!aaaa){ + printf("%d\n",MOD-1); + } + else + printf("%I64d\n",aaaa-1); + } + return 0; +} diff --git a/HDOJ/5452_autoAC.cpp b/HDOJ/5452_autoAC.cpp new file mode 100644 index 0000000..74e6b90 --- /dev/null +++ b/HDOJ/5452_autoAC.cpp @@ -0,0 +1,123 @@ +#include +#include +#include +#include +using namespace std; +#define INF 0x3f3f3f3f +const int maxn = 80010; +const int maxm = 26; +int dp[2*maxn][maxm]; +bool vis[maxn]; +struct edge +{ + int from, to; + int next; +} e[2*maxn]; +int tot,head[maxn]; +int cnt; +int num[maxn]; +void init() +{ + memset(head,-1,sizeof(head)); + memset(vis,false,sizeof(vis)); + memset(num,0,sizeof(num)); + cnt = 0; +} +void addedge(int u, int v) +{ + e[cnt].from = u; + e[cnt].to = v; + e[cnt].next = head[u]; + head[u] = cnt++; +} +int ver[2*maxn], R[2*maxn], first[maxn]; +void dfs(int u ,int dep) +{ + vis[u] = true; + ver[++tot] = u; + first[u] = tot; + R[tot] = dep; + for(int k=head[u]; k!=-1; k=e[k].next) + if( !vis[e[k].to] ) + { + int v = e[k].to; + dfs(v, dep+1); + ver[++tot] = u; + R[tot] = dep; + } +} +void ST(int n) +{ + for(int i=1; i<=n; i++) + dp[i][0] = i; + for(int j=1; (1< y) swap(x,y); + int res = RMQ(x,y); + return ver[res]; +} +int DFS(int u,int fa) +{ + for(int i = head[u]; ~i; i = e[i].next) + { + int v = e[i].to; + if(v == fa) + continue; + DFS(v, u); + num[u]+=num[v]; + } + return 0; +} +int main() +{ + int t; + int cas = 0; + int n, m; + scanf("%d",&t); + while(t--) + { + init(); + scanf("%d%d",&n,&m); + int u, v; + for(int i = 0; i < n-1; i++) + { + scanf("%d%d",&u,&v); + addedge(u, v); + addedge(v, u); + } + for(int i = n; i <= m; i++) + { + scanf("%d%d",&u,&v); + int tt = LCA(u, v); + num[u]++; + num[v]++; + num[tt]-=2; + } + DFS(1, 1); + int ans = INF; + for(int i = 2; i <= n; i++) + { + ans = min(ans, num[i]+1); + } + printf("Case #%d: %d\n",++cas,ans); + } + return 0; +} diff --git a/HDOJ/5454_autoAC.cpp b/HDOJ/5454_autoAC.cpp new file mode 100644 index 0000000..31b7067 --- /dev/null +++ b/HDOJ/5454_autoAC.cpp @@ -0,0 +1,157 @@ +#include +#include +#include +using namespace std; +typedef __int64 LL; +const int maxn = 300005; +struct tree +{ + LL suml[maxn << 2], sumr[maxn << 2], sum[maxn << 2]; + LL add[maxn << 2]; + inline void pushup(int id, int L, int R) + { + LL mid = L + R >> 1; + sum[id] = sum[id << 1] + sum[id << 1 | 1]; + suml[id] = suml[id << 1] + (mid - L + 1)*sum[id << 1 | 1] + suml[id << 1 | 1]; + sumr[id] = sumr[id << 1 | 1] + sumr[id << 1] + (R - mid)*sum[id << 1]; + } + inline void pushdown(int id, int L, int R) + { + int mid = L + R >> 1; + if (add[id]) + { + LL ln = mid - L + 1; + LL rn = R - mid; + add[id << 1] += add[id]; + add[id << 1 | 1] += add[id]; + sum[id << 1] += add[id] * ln; + sum[id << 1 | 1] += add[id] * rn; + suml[id << 1] += add[id] * (1 + ln)*ln >> 1; + suml[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1; + sumr[id << 1] += add[id] * (1 + ln)*ln >> 1; + sumr[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1; + add[id] = 0; + } + } + void build() + { + memset(sum, 0, sizeof(sum)); + memset(suml, 0, sizeof(suml)); + memset(sumr, 0, sizeof(sumr)); + memset(add, 0, sizeof(add)); + } + LL queL(int id, int L, int R, int l, int r) + { + if (l <= L&&R <= r) return (L - l)*sum[id] + suml[id]; + else + { + pushdown(id, L, R); + int mid = L + R >> 1; + LL res = 0; + if (l <= mid) res += queL(id << 1, L, mid, l, r); + if (mid> 1; + LL res = 0; + if (l <= mid) res += queR(id << 1, L, mid, l, r); + if (mid> 1; + LL res = 0; + if (l <= mid) res += que(id << 1, L, mid, l, r); + if (mid> 1; + sumr[id] += (1 + sn)*sn >> 1; + } + else + { + pushdown(id, L, R); + int mid = L + R >> 1; + if (l <= mid) op(id << 1, L, mid, l, r); + if (mid= max(A, C) + 1) ans += tz.queR(1, 1, n << 1, max(A, C) + 1, D); + if (B <= min(A, C) - 1) ans += tz.queL(1, 1, n << 1, B, min(A, C) - 1); + ans += tz.que(1, 1, n << 1, min(A, C), max(A, C))*(min(y2 - y1, x2 - x1) + 1); + A = x1 + y1; + B = x1 + y2; + C = x2 + y2; + D = x2 + y1; + if (A <= min(B, D) - 1) ans += tf.queL(1, 1, n << 1, A, min(B, D) - 1); + if (C >= max(B, D) + 1) ans += tf.queR(1, 1, n << 1, max(B, D) + 1, C); + ans += tf.que(1, 1, n << 1, min(B, D), max(B, D))*(min(y2 - y1, x2 - x1) + 1); + printf("%I64d\n", ans); + } + } + } + return 0; +} diff --git a/HDOJ/5455_autoAC.cpp b/HDOJ/5455_autoAC.cpp new file mode 100644 index 0000000..e9c6d6d --- /dev/null +++ b/HDOJ/5455_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define MAXN 100010 +using namespace std; +string s1; +int len,k,fg,cnt,ans,fg2; +int main(){ + int T,cas,i; + scanf("%d",&T); + getchar(); + for(cas=1;cas<=T;cas++) + { + char s2[MAXN]; + getline(cin,s1); + len=s1.length(); + fg=0; + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define ALL(a) a.begin(), a.end() +#define clr(a, x) memset(a, x, sizeof a) +#define X first +#define Y second +#define pb push_back +#define lowbit(x) (x&(-x)) +#define lson l,m,rt<<1 +#define rson m+1,r,rt<<1|1 +#define rep1(i,x,y) for(int i=x;i<=y;i++) +#define rep(i,n) for(int i=0;i<(int)n;i++) +using namespace std; +const double eps = 1e-6; +typedef long long LL; +typedef long long ll; +typedef pair pii; +const int oo =0x3f3f3f3f; +const int N = 510; +const int cnt[]= {6,2,5,5,4,5,6,3,7,6}; +ll d[N][2][8]; +int M,n; +bool vis[N][2][8]; +ll dp(int i,int j,int s) +{ + if(vis[i][j][s]) return d[i][j][s]; + vis[i][j][s] = 1; + d[i][j][s] = 0; + if(i == 0) + { + return d[i][j][s] = (j==0 && s==7); + } + rep(p,10) rep(q,10) + { + int nj = (p-j >= q ? 0 : 1); + int a = p, b = q , c = nj*10+p-j-q; + if((s&1) && c!=0) continue; + if((s&2) && b!=0) continue; + int nee = cnt[a]+((s&2) ? 0:cnt[b])+((s&1) ? 0 : cnt[c]); + if(nee > i) continue; + int vv[8]= {0}; + rep(t,8) + { + int ts = 0; + if((t&1) && (c>0)) ts|=1; + if((t&2) && (b>0)) ts|=2; + if((t&4) && (a>0) && nj==0 && i==nee) ts|=4; + if(!vv[ts]) d[i][j][s] = (d[i][j][s]+dp(i-nee,nj,s|ts))%M,vv[ts]=1; + } + } + return d[i][j][s]; +} +int main() +{ + int T,kase=1; + scanf("%d",&T); + while(T--) + { + scanf("%d %d",&n,&M); + memset(vis,false,sizeof(vis)); + printf("Case #%d: %I64d\n",kase++,dp(n-3,0,0)); + } + return 0; +} diff --git a/HDOJ/5457_autoAC.cpp b/HDOJ/5457_autoAC.cpp new file mode 100644 index 0000000..69e80c1 --- /dev/null +++ b/HDOJ/5457_autoAC.cpp @@ -0,0 +1,340 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#pragma comment(linker, "/STACK:1024000000,1024000000") +using namespace std; +#define eps 1e-9 +#define PI acos(-1.0) +#define INF 0x3f3f3f3f +#define LLINF 1LL<<60 +#define speed std::ios::sync_with_stdio(false); +typedef long long ll; +typedef unsigned long long ull; +typedef long double ld; +typedef pair pll; +typedef complex point; +typedef pair pii; +typedef pair piii; +typedef vector vi; +#define CLR(x,y) memset(x,y,sizeof(x)) +#define CPY(x,y) memcpy(x,y,sizeof(x)) +#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size)) +#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size)) +#define debug(a) cout << #a" = " << (a) << endl; +#define debugarry(a, n) for (int i = 0; i < (n); i++) { cout << #a"[" << i << "] = " << (a)[i] << endl; } +#define mp(x,y) make_pair(x,y) +#define pb(x) push_back(x) +#define lowbit(x) (x&(-x)) +#define MID(x,y) (x+((y-x)>>1)) +#define ls (idx<<1) +#define rs (idx<<1|1) +#define lson ls,l,mid +#define rson rs,mid+1,r +template +inline bool read(T &n) +{ + T x = 0, tmp = 1; + char c = getchar(); + while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar(); + if(c == EOF) return false; + if(c == '-') c = getchar(), tmp = -1; + while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar(); + n = x*tmp; + return true; +} +template +inline void write(T n) +{ + if(n < 0) + { + putchar('-'); + n = -n; + } + int len = 0,data[20]; + while(n) + { + data[len++] = n%10; + n /= 10; + } + if(!len) data[len++] = 0; + while(len--) putchar(data[len]+48); +} +const int MAXN=10240; +const int MAXM=40000; +struct ISAP +{ + struct nedge + { + int u,v,next; + ll c; + } e[MAXM*2]; + int head[MAXN],tot,n; + int ss,tt; + void Resize(int n) + { + this->n=n; + } + void Clearall() + { + tot=1; + CLR(head,0); + } + void addedge(int u,int v,ll w) + { + e[++tot].v=v; + e[tot].u=u; + e[tot].c=w; + e[tot].next=head[u]; + head[u]=tot; + e[++tot].v=u; + e[tot].u=v; + e[tot].c=0; + e[tot].next=head[v]; + head[v]=tot; + } + int dep[MAXN],gap[MAXN]; + void bfs() + { + CLR(dep,-1); + CLR(gap,0); + queue que; + gap[0]=1; + dep[tt]=0; + que.push(tt); + while(!que.empty()) + { + int u=que.front(); + que.pop(); + for(int i=head[u]; i; i=e[i].next) + if(dep[e[i].v]==-1) + { + que.push(e[i].v); + dep[e[i].v]=dep[u]+1; + ++gap[dep[e[i].v]]; + } + } + } + int res,cur[MAXN],num[MAXN]; + int top; + int MaxFlow(int s,int t) + { + this->ss=s; + this->tt=t; + bfs(); + top=res=0; + memcpy(cur,head,sizeof(head)); + int u=ss,i; + while(dep[ss]e[num[i]].c) + { + temp=e[num[i]].c; + inser=i; + } + for(i=0; i0 && mi>dep[e[i].v]) + { + mi=dep[e[i].v]; + cur[u]=i; + } + --gap[dep[u]]; + dep[u]=mi+1; + ++gap[dep[u]]; + if(u!=ss) + u=e[num[--top]].u; + } + } + return res; + } + void print() + { + puts("GRAPH:"); + for(int i=0; i<=n; i++) + { + if(!head[i]) + continue; + printf("%d ->",i); + for(int j=head[i]; j; j=e[j].next) + printf("%d(%I64d) ",e[j].v,e[j].c); + putchar('\n'); + } + } +}g; +static int tim; +struct Node +{ + Node *ln[2]; + int cost[2],idx; + bool f; + void init() + { + f=0; + idx=tim++; + memset(ln,0,sizeof ln); + memset(cost,INF,sizeof cost); + } +}; +struct Trie +{ + Node T[MAXN]; + int cnt,pos[MAXN]; + Node *rt; + Node* get() + { + T[cnt].init(); + return &T[cnt++]; + } + void init() + { + cnt=0; + rt=get(); + } + void insert(int *s,int j) + { + Node *p=rt; + for(int i=0; i<8; i++) + { + int v=s[i]; + if(p->ln[v]==NULL) p->ln[v]=get(); + p=p->ln[v]; + } + p->f=1; + pos[j]=p->idx; + } + void find(char *s,int cost) + { + Node *p=rt; + for(int i=0; s[i]; i++) + { + int v=s[i]-'0'; + if(p->ln[v]==NULL) return; + if(s[i+1]==0) p->cost[v]=min(p->cost[v],cost); + else p=p->ln[v]; + } + } +} pre,su; +int n,m,ss,tt; +int a[9]; +char str[9],x[9]; +void dfs(Node *p,int flag) +{ + if(flag) + { + if(p->ln[0]) + { + g.addedge(p->ln[0]->idx,p->idx,p->cost[0]); + dfs(p->ln[0],1); + } + if(p->ln[1]) + { + g.addedge(p->ln[1]->idx,p->idx,p->cost[1]); + dfs(p->ln[1],1); + } + } + else + { + if(p->ln[0]) + { + g.addedge(p->idx,p->ln[0]->idx,p->cost[0]); + dfs(p->ln[0],0); + } + if(p->ln[1]) + { + g.addedge(p->idx,p->ln[1]->idx,p->cost[1]); + dfs(p->ln[1],0); + } + } +} +void build() +{ + for(int i=1; i<=n; i++) + g.addedge(pre.pos[i],su.pos[i],INF); + dfs(pre.rt,0); + dfs(su.rt ,1); +} +int main() +{ + int T,cas=1; + read(T); + while(T--) + { + scanf("%d %d",&n,&m); + tim=0; + pre.init();su.init();g.Clearall(); + for(int i=1,x; i<=n; i++) + { + scanf("%d",&x); + for(int j=0; j<8; j++) + if(x&(1<<7-j)) a[j]=1; + else a[j]=0; + pre.insert(a,i); + for(int j=0; j<8; j++) + if(x&(1<idx; + for(int i=1,cost; i<=m; i++) + { + scanf("%s %s %d",str,x,&cost); + if(str[0]=='P') pre.find(x,cost); + else + { + int len=strlen(x); + reverse(x,x+len); + su.find(x,cost); + } + } + build(); + ll ans=g.MaxFlow(ss,tt); + printf("Case #%d: %lld\n",cas++,ans>=INF?-1:ans); + } + return 0; +} diff --git a/HDOJ/5458_autoAC.cpp b/HDOJ/5458_autoAC.cpp new file mode 100644 index 0000000..8d84d93 --- /dev/null +++ b/HDOJ/5458_autoAC.cpp @@ -0,0 +1,310 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#pragma comment(linker, "/STACK:1024000000,1024000000") +using namespace std; +#define eps 1e-9 +#define PI acos(-1.0) +#define INF 0x3f3f3f3f +#define LLINF 1LL<<62 +#define speed std::ios::sync_with_stdio(false); +typedef long long ll; +typedef unsigned long long ull; +typedef long double ld; +typedef pair pll; +typedef complex point; +typedef pair pii; +typedef pair piii; +typedef vector vi; +#define CLR(x,y) memset(x,y,sizeof(x)) +#define CPY(x,y) memcpy(x,y,sizeof(x)) +#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size)) +#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size)) +#define mp(x,y) make_pair(x,y) +#define pb(x) push_back(x) +#define lowbit(x) (x&(-x)) +#define MID(x,y) (x+((y-x)>>1)) +#define getidx(l,r) (l+r | l!=r) +#define ls getidx(l,mid) +#define rs getidx(mid+1,r) +#define lson l,mid +#define rson mid+1,r +#define root 1,n +template +inline bool read(T &n) +{ + T x = 0, tmp = 1; + char c = getchar(); + while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar(); + if(c == EOF) return false; + if(c == '-') c = getchar(), tmp = -1; + while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar(); + n = x*tmp; + return true; +} +template +inline void write(T n) +{ + if(n < 0) + { + putchar('-'); + n = -n; + } + int len = 0,data[20]; + while(n) + { + data[len++] = n%10; + n /= 10; + } + if(!len) data[len++] = 0; + while(len--) putchar(data[len]+48); +} +const int MAXN=30005; +const int MAXM=100005; +const int MAXQ=100005; +int t,n,m,q; +struct edge +{ + int a,b; + edge(){} + edge(int aa,int bb):a(aa),b(bb){} + bool operator < (const edge &o) const + { + if(a == o.a) + { + return b < o.b; + } + return a < o.a; + } +}; +multiset S; +multiset V; +struct Ans +{ + int kind; + int a; + int b; + int val; +}ans[MAXQ]; +struct Edge +{ + int u,v,w; + int next; +}e[MAXN<<1]; +int head[MAXN],tot; +int siz[MAXN],p[MAXN],son[MAXN],dep[MAXN]; +int dfn[MAXN],top[MAXN],tim; +int sum[MAXN<<1],la[MAXN<<1]; +int bingchafa[MAXN]; +int getfather(int x) +{ + if(bingchafa[x] == x) return x; + return bingchafa[x] = getfather(bingchafa[x]); +} +void init() +{ + CLR(head,-1);CLR(sum,0); + tot=tim=0; + for(int i=1;i<=n;i++) bingchafa[i] = i; + S.clear(); + V.clear(); +} +void addedge(int u,int v,int w) +{ + e[tot].u=u;e[tot].v=v;e[tot].w=w; + e[tot].next=head[u];head[u]=tot++; +} +void dfs(int u,int fa=0,int depth=0) +{ + siz[u]=1;son[u]=-1; + p[u]=fa;dep[u]=depth; + for(int i=head[u];~i;i=e[i].next) + { + int v=e[i].v; + if(v==p[u]) continue; + dfs(v,u,depth+1); + siz[u]+=siz[v]; + if(son[u]==-1 || siz[v]>siz[son[u]]) + son[u]=v; + } +} +void getid(int u,int fa) +{ + dfn[u]=++tim;top[u]=fa; + if(son[u]!=-1) + getid(son[u],fa); + for(int i=head[u];~i;i=e[i].next) + { + int v=e[i].v; + if(v==p[u] || v==son[u]) continue; + getid(v,v); + } +} +void pushup(int l,int r) +{ + int idx=getidx(l,r),mid=MID(l,r); + sum[idx]=0; + if(!la[ls]) + sum[idx]+=sum[ls]; + if(!la[rs]) + sum[idx]+=sum[rs]; +} +void pushdown(int l,int r) +{ + int idx=getidx(l,r),mid=MID(l,r); + if(!la[idx]) return; + la[ls]=la[idx]; + la[rs]=la[idx]; +} +void build(int l,int r) +{ + int idx=getidx(l,r); + la[idx]=0; + if(l==r) + { + sum[idx]=1; + return; + } + int mid=MID(l,r); + build(l,mid); + build(mid+1,r); + pushup(l,r); +} +void update2(int l,int r,int L,int R) +{ + int idx=getidx(l,r); + if(L==l && r==R) + { + la[idx]=1; + sum[idx]=0; + return; + } + pushdown(l,r); + int mid=MID(l,r); + if(R<=mid) + update2(l,mid,L,R); + else if(L>mid) + update2(mid+1,r,L,R); + else + update2(l,mid,L,mid),update2(mid+1,r,mid+1,R); + pushup(l,r); +} +int query(int l,int r,int L,int R) +{ + int idx=getidx(l,r); + if(la[idx]) return 0; + if(L==l && r==R) + { + return sum[idx]; + } + int mid=MID(l,r); + if(R<=mid) + return query(lson,L,R); + if(L>mid) + return query(rson,L,R); + return query(lson,L,mid)+query(rson,mid+1,R); +} +void change(int u,int v) +{ + while(top[u]!=top[v]) + { + if(dep[top[u]]>dep[top[v]]) + swap(u,v); + update2(1,tim,dfn[top[v]],dfn[v]); + v=p[top[v]]; + } + if(u==v) return; + if(dep[u]>dep[v]) + swap(u,v); + update2(1,tim,dfn[son[u]],dfn[v]); +} +int query(int u,int v) +{ + int ans=0; + while(top[u]!=top[v]) + { + if(dep[top[u]]>dep[top[v]]) + swap(u,v); + ans+=query(1,tim,dfn[top[v]],dfn[v]); + v=p[top[v]]; + } + if(u==v) return ans; + if(dep[u]>dep[v]) + swap(u,v); + ans+=query(1,tim,dfn[u]+1,dfn[v]); + return ans; +} +int main() +{ + scanf("%d",&t); + for(int cas = 1;cas <= t;cas++) + { + scanf("%d%d%d",&n,&m,&q); + init(); + for(int i=1;i<=m;i++) + { + edge tmp; + scanf("%d%d",&tmp.a,&tmp.b); + if(tmp.a > tmp.b) swap(tmp.a,tmp.b); + S.insert(tmp); + } + for(int i=1;i<=q;i++) + { + scanf("%d%d%d",&ans[i].kind,&ans[i].a,&ans[i].b); + if(ans[i].a > ans[i].b) swap(ans[i].a,ans[i].b); + if(ans[i].kind == 1) + { + multiset::iterator Pos = S.find(edge(ans[i].a,ans[i].b)); + S.erase(Pos); + } + } + for(multiset::iterator It = S.begin();It != S.end();++It) + { + if(getfather(It->a) != getfather(It->b)) + { + bingchafa[getfather(It->a)] = getfather(It->b); + V.insert(*It); + } + } + for(multiset::iterator It = V.begin();It != V.end();++It) + { + addedge(It->a,It->b,1); + addedge(It->b,It->a,1); + } + dfs(1);getid(1,1); + build(1,tim); + for(multiset::iterator It = S.begin();It != S.end();++It) + if(V.find(*It) == V.end()) + { + change(It->a,It->b); + } + for(int i=q;i>=1;i--) + { + if(ans[i].kind == 1) + change(ans[i].a,ans[i].b); + else if(ans[i].kind == 2) + ans[i].val = query(ans[i].a,ans[i].b); + } + printf("Case #%d:\n",cas); + for(int i=1;i<=q;i++) + if(ans[i].kind == 2) + printf("%d\n",ans[i].val); + } + return 0; +} diff --git a/HDOJ/5459_autoAC.cpp b/HDOJ/5459_autoAC.cpp new file mode 100644 index 0000000..4bf4f54 --- /dev/null +++ b/HDOJ/5459_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 201315; +const int mod = 530600414; +typedef long long LL; +LL dp[maxn]; +LL dist[maxn]; +LL cnt[maxn]; +LL fibo[maxn]; +void init() { + fibo[1] = 1, fibo[2] = 2; + cnt[1] = 1, cnt[2] = 0; + for (int i = 3; i < maxn; i ++) { + fibo[i] = (fibo[i-1] % mod + fibo[i-2] % mod) % mod; + cnt[i] = (cnt[i-1] % mod + cnt[i-2] % mod) % mod; + } + dist[1] = dist[2] = 0, dist[3] = 2; + for (int i = 4; i < maxn; i ++) { + dist[i] = (dist[i-1] % mod + dist[i-2] % mod + (fibo[i-1] % mod * cnt[i-2] % mod) % mod) % mod; + } + dp[4] = dp[1] = dp[2] = dp[3] = 0; + for (int i = 5; i < maxn; i ++) { + dp[i] = (dp[i-2] % mod + dp[i-1] % mod + + (cnt[i-1] % mod * dist[i-2] % mod) % mod + + (cnt[i-2] % mod * ((fibo[i-1] % mod * cnt[i-1] % mod) % mod - dist[i-1] % mod) % mod) % mod) % mod; + } +} +int main() { + init(); + int cas = 1, t, n; + scanf("%d", &t); + while (t --) { + scanf("%d", &n); + printf("Case #%d: ", cas ++); + printf("%I64d\n", dp[n]); + } + return 0; +} diff --git a/HDOJ/5460_autoAC.cpp b/HDOJ/5460_autoAC.cpp new file mode 100644 index 0000000..c53916c --- /dev/null +++ b/HDOJ/5460_autoAC.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +using namespace std; +const int maxn = (1<<8)+5; +const int limit = 32 * 13 * 13; +typedef long long ll; +typedef map::iterator iter; +int N, Q, X[20], multi[maxn], ct[maxn]; +map G[maxn]; +int bitcount(int s) { return s == 0 ? 0 : bitcount(s>>1) + (s&1); } +void add (int u, int s, ll k) { + if (s < 0) return; + G[u][s] += k; +} +void merge(int u, int p, int q) { + for (iter i = G[p].begin(); i != G[p].end(); i++) { + for (iter j = G[q].begin(); j != G[q].end(); j++) { + ll k = 1LL * i->second * j->second; + add(u, i->first + j->first, k * 2); + add(u, i->first * j->first, k * 2); + add(u, i->first - j->first, k); + add(u, j->first - i->first, k); + if (i->first && j->first % i->first == 0) + add(u, j->first / i->first, k); + if (j->first && i->first % j->first == 0) + add(u, i->first / j->first, k); + } + } +} +ll solve () { + ll ret = 0; + for (int i = 1; i < (1< +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair PLL; +PLL x[5],y[5]; +bool cmp1(const PLL &x,const PLL &y) {return x.first>y.first;} +bool cmp2(const PLL &x,const PLL &y) {return x.first0) + sort(x,x+5,cmp1); + else sort(x,x+5,cmp2); + if(b>0) + sort(y,y+5,cmp1); + else sort(y,y+5,cmp2); + } + } + LL ans=-1e20; + for(int i=0;i +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int maxn = 1005; +const double eps = 1e-7; +struct Point +{ + double x, y; + Point(double x = 0, double y = 0) : x(x), y(y) { } + bool operator < (const Point &a) const { + return a.x < x || (a.x == x && a.y < y); + } +}; +typedef Point Vector; +struct Line +{ + Point P; + Vector v; + double ang; + Line() {} + Line(Point P, Vector v) : P(P), v(v) { ang = atan2(v.y, v.x); } + bool operator < (const Line &L) const { + return ang < L.ang; + } +}; +Vector operator + (Vector A, Vector B) +{ + return Vector(A.x + B.x, A.y + B.y); +} +Vector operator - (Vector A, Vector B) +{ + return Vector(A.x - B.x, A.y - B.y); +} +Vector operator * (Vector A, double p) +{ + return Vector(A.x * p, A.y * p); +} +Vector operator / (Vector A, double p) +{ + return Vector(A.x / p, A.y / p); +} +int dcmp(double x) +{ + if(fabs(x) < eps) return 0; + else return x < 0 ? -1 : 1; +} +double Dot(Vector A, Vector B) +{ + return A.x * B.x + A.y * B.y; +} +double Length(Vector A) +{ + return sqrt(Dot(A, A)); +} +double Angle(Vector A, Vector B) +{ + return acos(Dot(A, B) / Length(A) / Length(B)); +} +double Cross(Vector A, Vector B) +{ + return A.x * B.y - A.y * B.x; +} +double Area2(Point A, Point B, Point C) +{ + return Cross(B - A, C - A); +} +double PolyonArea(Point *p, int n) +{ + double area = 0; + for(int i = 1; i < n-1; i++) + area += Cross(p[i] - p[0], p[i+1] - p[0]); + return area / 2; +} +Vector Rotate(Vector A, double rad) +{ + return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad)); +} +Vector Normal(Vector A) +{ + double L = Length(A); + return Vector(-A.y / L, A.x / L); +} +bool OnLeft(Line L, Point p) +{ + return Cross(L.v, p - L.P) > 0; +} +Point GetIntersection(Line a, Line b) +{ + Vector u = a.P - b.P; + double t = Cross(b.v, u) / Cross(a.v, b.v); + return a.P + a.v * t; +} +int ConvexHull(Point *p, int n, Point *ch) +{ + sort(p, p+n); + int m = 0; + for(int i = 0; i < n; i++) { + while(m > 1 && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--; + ch[m++] = p[i]; + } + int k = m; + for(int i = n-2; i >= 0; i--) { + while(m > k && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--; + ch[m++] = p[i]; + } + if(n > 1) m--; + return m; +} +Point p[maxn]; +Line q[maxn]; +int HalfplaneInersection(Line* L, int n, Point* poly) +{ + sort(L, L+n); + int first, last; + q[first = last = 0] = L[0]; + for(int i = 1; i < n; i++) { + while(first < last && !OnLeft(L[i], p[last - 1])) last--; + while(first < last && !OnLeft(L[i], p[first])) first++; + q[++last] = L[i]; + if(fabs(Cross(q[last].v, q[last-1].v)) < eps) { + last--; + if(OnLeft(q[last], L[i].P)) q[last] = L[i]; + } + if(first < last) p[last-1] = GetIntersection(q[last-1], q[last]); + } + while(first < last && !OnLeft(q[first], p[last-1])) last--; + if(last - first <= 1) return 0; + p[last] = GetIntersection(q[last], q[first]); + int m = 0; + for(int i = first; i <= last; i++) poly[m++] = p[i]; + return m; +} +double PolygonArea(Point *p, int n) { + double area = 0; + for(int i = 1; i < n-1; i++) + area += Cross(p[i] - p[0], p[i+1] - p[0]); + return fabs(area / 2); +} +Point poly[1005]; +Point g[105][2005]; +Point P2[10]; +Line line[105]; +double twox[105][2005]; +double twoy[105][2005]; +double xx[105][2005]; +double yy[105][2005]; +int n, m; +void work() +{ + scanf("%d%d", &n, &m); + for(int i = 1; i <= n; i++) { + twox[i][0] = twoy[i][0] = xx[i][0] = yy[i][0] = 0; + for(int j = 1; j <= m; j++) { + scanf("%lf%lf", &g[i][j].x, &g[i][j].y); + twox[i][j] = g[i][j].x * g[i][j].x; + twoy[i][j] = g[i][j].y * g[i][j].y; + twox[i][j] += twox[i][j-1]; + twoy[i][j] += twoy[i][j-1]; + xx[i][j] = g[i][j].x + xx[i][j-1]; + yy[i][j] = g[i][j].y + yy[i][j-1]; + } + } + for(int i = 1; i <= n; i++) { + int cnt = 0; + for(int j = 1; j <= n; j++) { + if(i == j) continue; + double a = 0, b = 0, c = 0; + a = 2 * (xx[i][m] - xx[j][m]); + b = 2 * (yy[i][m] - yy[j][m]); + c += twox[j][m] + twoy[j][m]; + c -= twox[i][m] + twoy[i][m]; + Point P; + Vector v(b, -a); + if(fabs(a) > fabs(b)) P = Point(-c / a, 0); + else P = Point(0, -c / b); + line[cnt++] = Line(P, v); + } + for(int j = 0; j < 4; j++) { + line[cnt++] = Line(P2[j], P2[(j+1)%4] - P2[j]); + } + int t = HalfplaneInersection(line, cnt, poly); + double area = PolygonArea(poly, t); + int ans = area + 0.5; + printf("%d%c", ans, i == n ? '\n' : ' '); + } +} +int main() +{ + P2[0] = Point(0, 0); + P2[1] = Point(4095, 0); + P2[2] = Point(4095, 4095); + P2[3] = Point(0, 4095); + int _; + scanf("%d", &_); + for(int i = 1; i <= _; i++) { + printf("Case #%d: ", i); + work(); + } + return 0; +} diff --git a/HDOJ/5463_autoAC.cpp b/HDOJ/5463_autoAC.cpp new file mode 100644 index 0000000..9b433e7 --- /dev/null +++ b/HDOJ/5463_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#include +const int maxn=1100; +int T; +int n,m,r; +int vis[maxn]; +int main() +{ + scanf("%d",&T); + while(T--){ + scanf("%d",&n); + memset(vis,0,sizeof(vis)); + int ans=0; + for(int i=0;i0){ + if(vis[i]%64==0){ + ans+=vis[i]/64; + } + else{ + ans+=vis[i]/64+1; + } + } + } + if(!ans%36) + printf("%d\n",ans/36); + else + printf("%d\n",ans/36+1); + } + return 0; +} diff --git a/HDOJ/5464_autoAC.cpp b/HDOJ/5464_autoAC.cpp new file mode 100644 index 0000000..898ab6c --- /dev/null +++ b/HDOJ/5464_autoAC.cpp @@ -0,0 +1,31 @@ +#include +#include +#include +#define ll long long +using namespace std; +const int N = 1005; +const int MOD = 1e9 + 7; +const int INF = 0x3f3f3f3f; +int n, p, a[N], f[N][N]; +int main() { + int t; + scanf("%d", &t); + while (t--) { + scanf("%d%d", &n, &p); + memset(f, 0, sizeof(f)); + f[0][0] = 1; + for (int i = 1; i <= n; i++) { + scanf("%d", &a[i]); + a[i] %= p; + a[i] = (a[i] + p) % p; + } + for (int i = 1; i <= n; i++) { + for (int j = 0; j < p; j++) { + f[i][j] = (f[i][j] + f[i - 1][j]) % MOD; + f[i][(j + a[i]) % p] = (f[i][(j + a[i]) % p] + f[i - 1][j]) % MOD; + } + } + printf("%d\n", f[n][0]); + } + return 0; +} diff --git a/HDOJ/5465_autoAC.cpp b/HDOJ/5465_autoAC.cpp new file mode 100644 index 0000000..82ec0b6 --- /dev/null +++ b/HDOJ/5465_autoAC.cpp @@ -0,0 +1,117 @@ +#pragma comment(linker, "/STACK:1677721600") +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define pb push_back +#define mp make_pair +#define LL long long +#define lson lo,mi,rt<<1 +#define rson mi+1,hi,rt<<1|1 +#define Min(a,b) ((a)<(b)?(a):(b)) +#define Max(a,b) ((a)>(b)?(a):(b)) +#define mem(a,b) memset(a,b,sizeof(a)) +#define rep(i,a,b) for(int i=(a); i<=(b); i++) +#define dec(i,a,b) for(int i=(a); i>=(b); i--) +using namespace std; +const int mod = 1e9 + 7; +const double eps = 1e-8; +const double ee = exp(1.0); +const int inf = 0x3f3f3f3f; +const int maxn = 500 + 10; +const double pi = acos(-1.0); +const LL iinf = 0x3f3f3f3f3f3f3f3f; +int readT() +{ + char c; + int ret = 0,flg = 0; + while(c = getchar(), (c < '0' || c > '9') && c != '-'); + if(c == '-') flg = 1; else ret = c ^ 48; + while( c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48); + return flg ? - ret : ret; +} +int c[maxn][maxn]; +int a[maxn][maxn]; +int n, m; +int lowbit(int x) +{ + return x & -x; +} +void update(int x, int y, int num) +{ + for (int i = x; i <= n; i += lowbit(i)) + { + for (int j = y; j <= m; j += lowbit(j)) + { + c[i][j] ^= num; + } + } +} +int query(int x, int y) +{ + int res = 0; + int t = x; + for (int i = x; i > 0; i -= lowbit(i)) + { + for (int j = y; j > 0; j -= lowbit(j)) + { + res ^= c[i][j]; + } + } + return res; +} +int sum(int x0, int y0, int x1, int y1) +{ + x0--, y0--; + return query(x1, y1) ^ query(x0, y1) ^ query(x1, y0) ^ query(x0, y0); +} +int main() +{ + int ncase = readT(); + while (ncase--) + { + mem(c, 0); + n = readT(); + m = readT(); + int q = readT(); + rep(i, 1, n) + { + rep(j, 1, m) + { + a[i][j] = readT(); + update(i, j, a[i][j]); + } + } + while (q--) + { + int op = readT(); + if (op == 1) + { + int x1 = readT(); + int y1 = readT(); + int x2 = readT(); + int y2 = readT(); + int ans = sum(x1, y1, x2, y2); + puts(ans ? "Yes" : "No"); + } + else + { + int x = readT(); + int y = readT(); + int num =readT(); + update(x, y, num ^ a[x][y]); + a[x][y] = num; + } + } + } + return 0; +} diff --git a/HDOJ/5467_autoAC.cpp b/HDOJ/5467_autoAC.cpp new file mode 100644 index 0000000..a97b730 --- /dev/null +++ b/HDOJ/5467_autoAC.cpp @@ -0,0 +1,236 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +#define mp(x, y) make_pair(x, y) +const int maxn = 300005; +const int maxm = 300005; +const int INF = 0x3f3f3f3f; +const int mod = 1e9+7; +struct node *null; +struct node +{ + int size, rev; + LL val, sum; + node *fa, *ch[2]; + void init() + { + rev = val = sum = 0; + fa = ch[0] = ch[1] = null; + } + inline bool d() + { + return fa->ch[1] == this; + } + inline bool isroot() + { + return fa == null || fa->ch[0] != this && fa->ch[1] != this; + } + inline void setc(node *p, int d) + { + ch[d] = p; + p->fa = this; + } + inline void pushup() + { + sum = ch[0]->sum * ch[1]->sum % mod * ((val - 1) * val / 2) % mod; + } + inline void flip() + { + if(this == null) return; + swap(ch[0], ch[1]); + rev ^= 1; + } + inline void pushdown() + { + if(rev) { + ch[0]->flip(); + ch[1]->flip(); + rev = 0; + } + } + inline void go() + { + if(!isroot()) fa->go(); + pushdown(); + } + void rot() + { + node *f = fa, *ff = fa->fa; + int c = d(), cc = fa->d(); + f->setc(ch[!c], c); + this->setc(f, !c); + if(ff->ch[cc] == f) ff->setc(this, cc); + else this->fa = ff; + f->pushup(); + } + node* splay() + { + go(); + while(!isroot()) { + if(!fa->isroot()) d() == fa->d() ? fa->rot() : rot(); + rot(); + } + pushup(); + return this; + } + node* access() + { + for(node *p = this, *q = null; p != null; q = p, p = p->fa) { + p->splay()->setc(q, 1); + p->pushup(); + } + return splay(); + } + inline void makeroot() + { + access()->flip(); + } + node* getroot() { + node *x; + for(x = access(); x->pushdown(), x->ch[0] != null; x = x->ch[0]); + return x; + } + void cut() + { + access(); + ch[0]->fa = null; + ch[0] = null; + pushup(); + } + void cut(node *o) + { + makeroot(); + o->cut(); + } + void link(node *p) + { + makeroot(); + fa = p; + } +}*Node[maxn], pool[maxm], *tail; +struct ope +{ + int kk, u, v; + ope(int kk = 0, int u = 0, int v = 0) : kk(kk), u(u), v(v) {} +}op[maxn]; +struct Edge +{ + int v; + Edge *next; +}*H[maxn], *edges, E[maxn]; +vector to[maxn]; +LL res[maxn]; +int T[maxn]; +int a[maxn]; +int n, m; +void addedges(int u, int v) +{ + edges->v = v; + edges->next = H[u]; + H[u] = edges++; +} +node* newnode(int val) +{ + tail->init(); + tail->val = val; + tail->sum = tail->val * (tail->val - 1) / 2; + return tail++; +} +void init() +{ + tail = pool; + null = newnode(1); + null->sum = 1; + edges = E; + memset(H, 0, sizeof H); + memset(T, 0, sizeof T); + memset(res, -1, sizeof res); +} +bool add(int u, int v) +{ + if(u == v) return 0; + if(Node[u]->getroot() == Node[v]->getroot()) return 0; + Node[u]->link(Node[v]); + return true; +} +bool del(int u, int v) +{ + if(u == v) return 0; + if(Node[u]->getroot() != Node[v]->getroot()) return 0; + Node[u]->makeroot(); + Node[v]->access(); + if(Node[v]->ch[0] != Node[u] || Node[u]->ch[1] != null) return 0; + else Node[v]->cut(Node[u]); + return 1; +} +LL query(node *a, node *b) +{ + a->access(); + for(a = null; b != null; a = b, b = b->fa) { + b->splay(); + if(b->fa == null) return b->ch[1]->sum * a->sum % mod * (b->val * (b->val - 1) / 2) % mod; + b->setc(a, 1); + b->pushup(); + } +} +void modify(int u, LL val) +{ + Node[u]->access(); + Node[u]->val = val; + Node[u]->pushup(); +} +void dfs(int ti) +{ + LL tmp = 0; + int flag = 0; + if(op[ti].kk == 1) flag = add(op[ti].u, op[ti].v); + if(op[ti].kk == 2) flag = del(op[ti].u, op[ti].v); + if(op[ti].kk == 4) { + if(Node[op[ti].u]->getroot() != Node[op[ti].v]->getroot()) res[ti] = 0; + else res[ti] = query(Node[op[ti].u], Node[op[ti].v]); + } + if(op[ti].kk == 5) { + tmp = a[op[ti].u]; + a[op[ti].u] = op[ti].v; + modify(op[ti].u, op[ti].v); + } + for(Edge *e = H[ti]; e; e = e->next) dfs(e->v); + if(op[ti].kk == 2 && flag) add(op[ti].u, op[ti].v); + if(op[ti].kk == 1 && flag) del(op[ti].u, op[ti].v); + if(op[ti].kk == 5) { + a[op[ti].u] = tmp; + modify(op[ti].u, tmp); + } +} +void work() +{ + scanf("%d%d", &n, &m); + for(int i = 1; i <= n; i++) to[i].clear(); + for(int i = 1; i <= n; i++) scanf("%d", &a[i]); + for(int i = 1; i <= n; i++) Node[i] = newnode(a[i]); + for(int i = 1; i <= m; i++) { + int kk, u, v; + scanf("%d", &kk); + if(kk == 3) scanf("%d", &u), T[i] = u; + else scanf("%d%d", &u, &v), T[i] = i-1; + op[i] = ope(kk, u, v); + } + for(int i = 1; i <= m; i++) addedges(T[i], i); + dfs(0); + for(int i = 1; i <= m; i++) if(res[i] != -1) printf("%lld\n", res[i]); +} +int main() +{ + int _; + scanf("%d", &_); + while(_--) { + init(); + work(); + } + return 0; +} diff --git a/HDOJ/5468_autoAC.cpp b/HDOJ/5468_autoAC.cpp new file mode 100644 index 0000000..cfb3184 --- /dev/null +++ b/HDOJ/5468_autoAC.cpp @@ -0,0 +1,166 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const LL LINF = (1LL <<63); +const int INF = 1 << 31; +const int NS = 100010; +const int MS = 19; +const int MOD = 1000000007; +const int EDGE_MAX = NS; +struct graphEdge +{ + int pst; + int next; +}; +struct ForwardStart +{ + int top; + int head[EDGE_MAX]; + graphEdge edge[EDGE_MAX << 1]; + void init(int len) + { + top = 0; + memset(head, -1, sizeof(int) * len); + } + void addEdge(int u, int v) + { + edge[top].pst = v; + edge[top].next = head[u]; + head[u] = top++; + } + void printAll() + { + printf("top = %d\n", top); + for(int i = 1; i < EDGE_MAX; i++) + { + if(-1 != head[i]) + { + printf("head[%2d]'son:%2d", i, edge[head[i]].pst); + for(int j = edge[head[i]].next; j != -1; j = edge[j].next) + { + printf(",%2d", edge[j].pst); + } + puts(""); + } + } + } +}cTree; +bitset isPrime; +vector fac[NS]; +int miu[NS]; +void prepare() +{ + isPrime.set(); + isPrime[1] = false; + miu[1] = 1; + for(int i = 2; i < NS; i++) + { + if(isPrime[i]) + { + for(int j = i; j < NS; j+=i) + { + isPrime[j] = false; + int k = j / i; + if(k % i) + { + miu[j] = -miu[k]; + } + else + { + miu[j] = 0; + } + fac[j].push_back(i); + } + } + else + { + if(miu[i] != 0) + { + for(int j = i; j < NS; j+=i) + { + fac[j].push_back(i); + } + } + } + } +} +int n; +int val[NS]; +int ans[NS]; +int sz[NS]; +int dp[NS]; +void dfs(int rt, int fa) +{ + vector temp; + sz[rt] = 1; + int value = val[rt]; + int len = fac[value].size(); + for(int i = 0; i < len; i++) + { + int d = fac[value][i]; + int cnt = dp[d]; + temp.push_back(cnt); + dp[d] += 1; + } + for(int i = cTree.head[rt]; i != -1; i = cTree.edge[i].next) + { + int cson = cTree.edge[i].pst; + if(cson == fa) continue; + dfs(cson, rt); + sz[rt] += sz[cson]; + } + ans[rt] = sz[rt]; + for(int i = 0; i < len; i++) + { + int d = fac[value][i]; + int cnt = dp[d] - temp[i]; + if(cnt > 0) + { + ans[rt] += miu[d] * cnt; + } + } + return ; +} +int main() +{ + prepare(); + int nCase = 1; + while(~scanf("%d", &n)) + { + cTree.init(n + n + 2); + int u, v; + for(int i = 1; i < n; i++) + { + scanf("%d %d", &u, &v); + cTree.addEdge(u, v); + cTree.addEdge(v, u); + } + for(int i = 1; i <= n; i++) + { + scanf("%d", &val[i]); + if(val[i] < 0) + { + val[i] = - val[i]; + } + } + memset(dp, 0, sizeof(dp)); + dfs(1, -1); + printf("Case #%d:", nCase++); + for(int i = 1; i <= n; i++) + { + printf(" %d", ans[i]); + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/5469_autoAC.cpp b/HDOJ/5469_autoAC.cpp new file mode 100644 index 0000000..678c0f8 --- /dev/null +++ b/HDOJ/5469_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +using namespace std; +#define N 10010 +vectorG[N]; +int n,len; +char value[N],an[N]; +int dis[N]; +int f[N]; +bool visit[N]; +void init() { + for(int i = 1; i <= n; i++) G[i].clear(); + memset(dis,0,sizeof(dis)); + memset(visit,0,sizeof(visit)); +} +void dfs(int u) { + int ma = -10000000; + visit[u] = 1; + for(int i = 0; i < G[u].size(); i++) + if(!visit[G[u][i]]) { + dfs(G[u][i]); + f[G[u][i]] = u; + ma = max(ma,dis[G[u][i]]); + } + if(ma == -10000000) + dis[u] = 1; + else + dis[u] = ma+1; +} +bool dfs1(int u,int x,int len1) { + visit[u] = 1; + if(x > len) return 1; + if(dis[u] > len1) + for(int i = 0; i < G[u].size(); i++) { + if(value[G[u][i]] == an[x] && !visit[G[u][i]]) { + if(dfs1(G[u][i],x+1,len1-1)) return 1; + } + } + else { + if(value[f[u]] == an[x] && !visit[f[u]]) { + return dfs1(f[u],x+1,len1-1); + } + } + return 0; +} +int main() { + int t;scanf("%d",&t); + int ca = 1; + while(t--) { + scanf("%d",&n); + init(); + int x,y; + for(int i = 1; i < n; i++) { + scanf("%d%d",&x,&y); + G[x].push_back(y); + G[y].push_back(x); + } + scanf("%s",value+1); + scanf("%s",an+1); + dfs(1); bool flag = 0; + len = strlen(an+1); + for(int i = 1; i <= n; i++) + if(value[i] == an[1]) { + memset(visit,0,sizeof(visit)); + if(dfs1(i,2,len-1)) { + printf("Case #%d: Find\n",ca++); + flag = 1; + break; + } + } + if(!flag) printf("Case #%d: Impossible\n",ca++); + } + return 0; +} diff --git a/HDOJ/5470_autoAC.cpp b/HDOJ/5470_autoAC.cpp new file mode 100644 index 0000000..412867b --- /dev/null +++ b/HDOJ/5470_autoAC.cpp @@ -0,0 +1,114 @@ +#include +#include +#include +#include +const int N = 100000; +const int C = 26; +char s[N + 1]; +struct State { + int length; + int first; + State* parent; + State* go[C]; + State* extend(State*, int); +}; +int state_count; +State states[N << 1]; +State* new_state(int length) { + State* state = states + (state_count ++); + state->length = length; + state->first = -1; + state->parent = NULL; + memset(state->go, 0, sizeof(state->go)); + return state; +} +State* State::extend(State* start, int token) { + State *p = this; + State *np = new_state(length + 1); + while (p && !p->go[token]) { + p->go[token] = np; + p = p->parent; + } + if (!p) { + np->parent = start; + } else { + State *q = p->go[token]; + if (p->length + 1 == q->length) { + np->parent = q; + } else { + State *nq = new_state(p->length + 1); + memcpy(nq->go, q->go, sizeof(q->go)); + nq->parent = q->parent; + np->parent = q->parent = nq; + while (p && p->go[token] == q) { + p->go[token] = nq; + p = p->parent; + } + } + } + return np; +} +int cost[C], a, b, match[N + 1], queue[N + 1]; +State* end[N + 1]; +long long minimum[N + 1]; +int main() { + int T; + scanf("%d", &T); + for (int t = 1; t <= T; ++ t) { + scanf("%s", s); + for (int i = 0; i < C; ++ i) { + scanf("%d", cost + i); + } + scanf("%d%d", &a, &b); + int n = strlen(s); + state_count = 0; + end[0] = new_state(0); + for (int i = 0; i < n; ++ i) { + end[i + 1] = end[i]->extend(end[0], s[i]- 'a'); + } + for (int i = 0; i < n; ++ i) { + for (State* p = end[i + 1]; p && !~p->first; p = p->parent) { + p->first = i; + } + } + State* p = end[0]; + for (int i = 0, l = 0; i < n; ++ i) { + int c = s[i] - 'a'; + while (!p->go[c]) { + p = p->parent; + l = std::min(l, p->length); + } + p = p->go[c]; + l ++; + while (p->first > i - l) { + l --; + if (p->parent->length == l) { + p = p->parent; + } + } + match[i + 1] = l; + } + minimum[0] = 0; + int head = 0; + int tail = 0; + queue[tail ++] = 0; + for (int i = 1; i <= n; ++ i) { + minimum[i] = minimum[i - 1] + cost[s[i - 1] - 'a']; + while (head < tail && queue[head] < i - match[i]) { + head ++; + } + if (head < tail) { + int j = queue[head]; + minimum[i] = std::min(minimum[i], minimum[j] + (long long)a * (i - j) + b + b); + } +#define VALUE(i) (minimum[i] - (long long)a * (i)) + while (head < tail && VALUE(queue[tail - 1]) > VALUE(i)) { + tail --; + } +#undef VALUE + queue[tail ++] = i; + } + std::cout << "Case #" << t << ": " << minimum[n] << std::endl;; + } + return 0; +} diff --git a/HDOJ/5471_autoAC.cpp b/HDOJ/5471_autoAC.cpp new file mode 100644 index 0000000..a8ccb64 --- /dev/null +++ b/HDOJ/5471_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxn = 1024 + 5; +const int mod = 1e9 + 7; +struct Rectangle { + int x1, y1, x2, y2, c; + Rectangle (int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0, int c = 0): x1(x1), y1(y1), x2(x2), y2(y2), c(c) {} + void read() { scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c); } + int size() { return (x2-x1+1)*(y2-y1+1); } + bool in(const Rectangle& u) const { + return x1 <= u.x1 && u.x2 <= x2 && y1 <= u.y1 && u.y2 <= y2; + } +}R[15]; +int N, M, H, W, cc, all, ct[15][maxn], sz[15][maxn]; +vector X, Y, C, G[15]; +int bitcount(int x) { return x == 0 ? 0 : bitcount(x>>1) + (x&1); } +void init () { + scanf("%d%d%d%d", &H, &W, &M, &N); + X.clear(), Y.clear(), C.clear(); + for (int i = 0; i < N; i++) { + R[i].read(); + X.push_back(R[i].x1-1); + X.push_back(R[i].x2); + Y.push_back(R[i].y1-1); + Y.push_back(R[i].y2); + C.push_back(R[i].c); + } + X.push_back(0); + X.push_back(H); + Y.push_back(0); + Y.push_back(W); + sort(X.begin(), X.end()); + sort(Y.begin(), Y.end()); + sort(C.begin(), C.end()); + int cx = unique(X.begin(), X.end()) - X.begin(); + int cy = unique(Y.begin(), Y.end()) - Y.begin(); + cc = unique(C.begin(), C.end()) - C.begin(); + int id[15], rk[15]; + for (int i = 0; i < cc; i++) G[i].clear(); + for (int i = 0; i < N; i++) { + id[i] = lower_bound(C.begin(), C.begin()+cc, R[i].c) - C.begin(); + rk[i] = G[id[i]].size(); + G[id[i]].push_back(i); + } + all = 0; + memset(ct, 0, sizeof(ct)); + memset(sz, 0, sizeof(sz)); + for (int x = 1; x < cx; x++) { + for (int y = 1; y < cy; y++) { + int t = cc, s = 0; + Rectangle tmp = Rectangle(X[x-1]+1, Y[y-1]+1, X[x], Y[y]); + for (int i = 0; i < N; i++) { + if (R[i].in(tmp)) { + if (id[i] < t) + s = 0, t = id[i]; + if (t == id[i]) + s |= (1<>= 1; + } + return ret; +} +int solve () { + ll ret = pow_mod(M, all); + for (int i = 0; i < cc; i++) { + int t = 0, n = (1< +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +struct Point { + ll x, y; + Point(ll x = 0, ll y = 0): x(x), y(y) {} + void read() { scanf("%lld%lld", &x, &y); } + bool operator < (const Point& u) const { return x < u.x || (x == u.x && y < u.y); } + bool operator == (const Point& u) const { return !(*this < u) && !(u < *this); } + bool operator != (const Point& u) const { return !(*this == u); } + bool operator > (const Point& u) const { return u < *this; } + bool operator <= (const Point& u) const { return *this < u || *this == u; } + bool operator >= (const Point& u) const { return *this > u || *this == u; } + Point operator + (const Point& u) { return Point(x + u.x, y + u.y); } + Point operator - (const Point& u) { return Point(x - u.x, y - u.y); } + Point operator * (const double u) { return Point(x * u, y * u); } + Point operator / (const double u) { return Point(x / u, y / u); } + ll operator ^ (const Point& u) { return x*u.y - y*u.x; } +}; +typedef Point Vector; +ll Cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; } +ll getArea (Point* p, int n) { + ll ret = 0; + for (int i = 0; i < n-1; i ++) + ret += Cross(p[i]-p[0], p[i+1]-p[0]); + return ret < 0 ? -ret : ret; +} +int getConvexHull (Point* p, int n, Point* ch) { + sort(p, p + n); + int m = 0; + for (int i = 0; i < n; i++) { + while (m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--; + ch[m++] = p[i]; + } + int k = m; + for (int i = n-2; i >= 0; i--) { + while (m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--; + ch[m++] = p[i]; + } + if (n > 1) m--; + return m; +} +const int maxn = 105; +int N, K; +ll dp[maxn][maxn]; +Point P[maxn], Q[maxn]; +ll solve () { + ll allarea = getArea(P, N); + if (K >= N) return allarea; + ll ret = 0; + bool vis[maxn]; + memset(vis, 0, sizeof(vis)); + int ti = min(5 * (N / K), N); + for (int t = 0; t < ti; t++) { + int s = rand() % N; + while (vis[s]) s = rand() % N; + vis[s] = 1; + memset(dp, 0, sizeof(dp)); + dp[0][0] = allarea; + for (int i = 1; i <= N; i++) { + int u = (i + s) % N; + ll sum = 0; + for (int j = i-1; j >= 0; j--) { + int v = (j + s) % N; + int p = (v + 1) % N; + ll tmp = ((P[p]-P[u])^(P[v]-P[u])); + if (tmp < 0) tmp = -tmp; + sum += tmp; + for (int x = K; x > 0; x--) + dp[i][x] = max(dp[i][x], dp[j][x-1]-sum); + } + } + ret = max(ret, dp[N][K]); + } + return ret; +} +int main () { + int cas; + scanf("%d", &cas); + srand((int)time(NULL)); + for (int kcas = 1; kcas <= cas; kcas++) { + scanf("%d%d", &N, &K); + for (int i = 0; i < N; i++) Q[i].read(); + N = getConvexHull(Q, N, P); + printf("Case #%d: %lld\n", kcas, solve()); + } + return 0; +} diff --git a/HDOJ/5475_autoAC.cpp b/HDOJ/5475_autoAC.cpp new file mode 100644 index 0000000..f28a2ab --- /dev/null +++ b/HDOJ/5475_autoAC.cpp @@ -0,0 +1,83 @@ +#include +#include +#include +#include +using namespace std; +typedef long long ll; +#define lson l,m,rt<<1 +#define rson m+1,r,rt<<1|1 +const int maxn=155555; +ll sum[maxn*4+4]; +int add; +int a[maxn]; +int L,R; +int MOD; +int p; +void pushup(int rt){ + sum[rt]=sum[rt<<1]*sum[rt<<1|1]%MOD; +} +void build(int l,int r,int rt){ + if(l==r){ + sum[rt]=1; + return ; + } + int m=(l+r)>>1; + build(lson); + build(rson); + pushup(rt); +} +void update(int l,int r,int rt){ + if(l==r){ + sum[rt]=add; + return ; + } + int m=(l+r)>>1; + if(p<=m) + update(lson); + else + update(rson); + pushup(rt); +} +ll query(int l,int r,int rt){ + ll ret=1; + if(L<=l&&R>=r) + return sum[rt]; + int m=(l+r)>>1; + if(L<=m) + ret*=query(lson)%MOD; + if(R>m) + ret*=query(rson)%MOD; + return ret%MOD; +} +int main() +{ + int n,m; + int op,u,q; + int t; + scanf("%d",&t); + for(int case1=1;case1<=t;case1++){ + printf("Case #%d:\n",case1); + scanf("%d%d",&q,&MOD); + build(1,q,1); + for(int i=1;i<=q;i++){ + scanf("%d%d",&op,&u); + if(op==1){ + p=i; + add=u; + update(1,q,1); + L=1; + R=i; + printf("%I64d\n",query(1,q,1)%MOD); + } + else{ + p=u; + add=1; + update(1,q,1); + L=1; + R=i; + printf("%I64d\n",query(1,q,1)%MOD); + } + } + } + return 0; +} diff --git a/HDOJ/5476_autoAC.cpp b/HDOJ/5476_autoAC.cpp new file mode 100644 index 0000000..86c4ae3 --- /dev/null +++ b/HDOJ/5476_autoAC.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define pi (2*acos(0)) +#define maxn 1000000 +using namespace std; +int main() +{ + int t; + scanf("%d", &t); + for (int k=1;k<=t;k++) + { + double ax, ay, bx, by, cx, cy; + scanf("%lf%lf%lf%lf%lf%lf", &ax, &ay, &bx, &by, &cx, &cy); + double t1 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by); + double ab = sqrt(t1); + double t2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy); + double bc = sqrt(t2); + double h = sqrt(t1 - t2/4); + double angle = acos(bc/(2.0*ab)); + double d = bc / sin(angle); + double ans = 0; + ans = d * angle; + ans = ans + h; + printf("Case #%d: %.4f\n", k, ans); + } + return 0; +} diff --git a/HDOJ/5479_autoAC.cpp b/HDOJ/5479_autoAC.cpp new file mode 100644 index 0000000..1c91376 --- /dev/null +++ b/HDOJ/5479_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define INF 0x3f3f3f3f +#define inf -0x3f3f3f3f +#define lson l,m,rt<<1 +#define rson m+1,r,rt<<1|1 +#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)) +typedef long long ll; +char s[1010]; +int l[1010],r[1010]; +int main(){ + int t; + scanf("%d",&t); + while(t--){ + scanf("%s",s); + mem0(l); + mem0(r); + int len=strlen(s); + for(int i=len-1;i>=0;i--){ + if(i==len-1) + r[i]=(s[i]==')'); + else + r[i]=r[i+1]+(s[i]==')'); + } + for(int i=0;i +#include +#include +#define N 110000 +#define pr pair +#define lson l,mid,no<<1 +#define rson mid+1,r,no<<1|1 +#define mod 1000000007ll +using namespace std; +typedef long long ll; +int dis[N<<1],len; +pr L[N]; +ll sum[N<<3],cov[N<<3]; +ll P[N],S[N]; +void Pushdown(int no,int len) +{ + if(cov[no]) + { + cov[no<<1]+=cov[no]; + cov[no<<1|1]+=cov[no]; + sum[no<<1]+=cov[no]*(len-(len>>1)); + sum[no<<1|1]+=cov[no]*(len>>1); + cov[no]=0; + } +} +void Pushup(int no) +{ + sum[no]=sum[no<<1]+sum[no<<1|1]; +} +void update(int l,int r,int no,int st,int en) +{ + if(st<=l&&r<=en) + { + cov[no]++; + sum[no]+=r-l+1; + } + else + { + int mid=l+r>>1; + Pushdown(no,r-l+1); + if(en<=mid) update(lson,st,en); + else if(st>mid) update(rson,st,en); + else update(lson,st,en),update(rson,st,en); + Pushup(no); + } +} +int query(int l,int r,int no,int k) +{ + if(l==r) + return sum[no]; + else + { + int mid=l+r>>1; + Pushdown(no,r-l+1); + if(k<=mid) return query(lson,k); + else return query(rson,k); + } +} +int main() +{ + int c,T; + int n,i,l,r; + scanf("%d",&T); + P[1]=1; + for(i=2;i +#include +#include +#include +using namespace std; +#define scan(x) scanf("%d",&(x)) +#define scan2(x,y) scanf("%d%d",&(x),&(y)) +#define scan3(x,y,z) scanf("%d%d%d",&(x),&(y),&(z)) +#define scan4(x,y,z,k) scanf("%d%d%d%d",&(x),&(y),&(z),&(k)) +const int maxn = 3003; +const int maxm = maxn * maxn; +const int inf = 1000000000; +int n, m; +__int64 mst; +int map[maxn][maxn]; +int dp[maxn][maxn], best[maxn][maxn]; +int dis[maxn], pre[maxn]; +bool vis[maxn]; +vector edge[maxn]; +#include +int minz(int a, int b) +{ + return a < b ? a : b; +} +void init() +{ + int i, j; + for(i = 0; i < n; i++) + { + for(j = 0; j < n; j++) + map[i][j] = dp[i][j] = inf; + edge[i].clear(); + vis[i] = 0; + pre[i] = -1; + dis[i] = inf; + } +} +void input() +{ + for(int i=0;i dis[j]) + k = j; + vis[k] = 1; + mst += dis[k]; + if(pre[k] != -1) + edge[k].push_back(pre[k]), + edge[pre[k]].push_back(k); + for(j = 1; j < n; j++) + if(!vis[j] && dis[j] > map[k][j] ) + dis[j] = map[k][j], pre[j] = k; + } +} +int dfs1(int u, int fa, int rt) +{ + int i; + for(i = 0; i < edge[u].size(); i++) + { + int v = edge[u][i]; + if(v == fa) continue; + dp[rt][u] = minz(dp[rt][u], dfs1(v, u, rt)); + } + if(fa != rt) dp[rt][u] = minz(dp[rt][u], map[rt][u]); + return dp[rt][u]; +} +int dfs2(int u, int fa, int rt) +{ + int i; + int ans = dp[u][rt]; + for(i = 0; i < edge[u].size(); i++) + { + int v = edge[u][i]; + if(v == fa) continue; + ans = minz(ans, dfs2(v, u, rt)); + } + return ans; +} +void solve() +{ + int i,j; + for(i = 0; i < n; i++) + dfs1(i, -1, i); + for(i = 0; i < n; i++) + for(j = 0; j < edge[i].size(); j++) + { + int v = edge[i][j]; + best[i][v] = best[v][i] = dfs2(v, i, i); + } +} +void query() +{ + int ans =0 ; + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 1000006 +#define mod 1000000007 +#define eps 1e-9 +#define e exp(1.0) +#define PI acos(-1) +const double EP = 1E-10 ; +int Num; +const ll inf=999999999; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +vector Q; +map H; +struct node +{ + int x,y; +}; +node p[maxn]; +int b[maxn]; +vector Q1[maxn]; +int main() +{ + int t=read(); + for(int cas=1;cas<=t;cas++) + { + int n=read(); + H.clear(); + for(int i=1;i<=n;i++) + { + p[i].x=read(),p[i].y=read(); + Q.push_back(p[i].x); + Q.push_back(p[i].y); + } + sort(Q.begin(),Q.end()); + Q.erase(unique(Q.begin(),Q.end()),Q.end()); + int len = Q.size(); + for(int i=0;i +#include +#include +#include +#include +#include +#include +using namespace std; +#define maxn 1005 +int n1, m1, k1; +int n2, m2, k2; +bool tar1[maxn]; +bool tar2[maxn]; +int go1[maxn][26]; +int go2[maxn][26]; +int prestate[maxn*maxn]; +char prechar[maxn*maxn]; +bool vis[maxn*maxn]; +bool check(int x) +{ + return tar1[x / n2] != tar2[x%n2]; +} +int nextState(int x, int c) +{ + return go1[x / n2][c] * n2 + go2[x%n2][c]; +} +int main() +{ + int T; cin >> T; int ca = 0; + while (T--) + { + memset(go1, -1, sizeof(go1)); + memset(go2, -1, sizeof(go2)); + memset(tar1, 0, sizeof(tar1)); + memset(tar2, 0, sizeof(tar2)); + int accept; + int ui, vi; + char ci[3]; + scanf("%d%d%d", &n1, &m1, &k1); + for (int i = 0; i < k1; ++i){ + scanf("%d", &accept); + tar1[accept] = true; + } + for (int i = 0; i < m1; ++i){ + scanf("%d%d%s", &ui, &vi, ci); + go1[ui][ci[0] - 'a'] = vi; + } + for (int i = 0; i <= n1; ++i){ + for (int k = 0; k < 26; ++k){ + if (go1[i][k] == -1) go1[i][k] = n1; + } + } + scanf("%d%d%d", &n2, &m2, &k2); + for (int i = 0; i < k2; ++i){ + scanf("%d", &accept); + tar2[accept] = true; + } + for (int i = 0; i < m2; ++i){ + scanf("%d%d%s", &ui, &vi, ci); + go2[ui][ci[0] - 'a'] = vi; + } + for (int i = 0; i <= n2; ++i){ + for (int k = 0; k < 26; ++k){ + if (go2[i][k] == -1) go2[i][k] = n2; + } + } + ++n1; ++n2; + int ans = -1; + memset(vis, 0, sizeof(vis)); + queue Q; + Q.push(0); + vis[0] = true; + while (!Q.empty()) + { + int state = Q.front(); Q.pop(); + if (check(state)){ + ans = state; + break; + } + for (int k = 0; k < 26; ++k){ + int nstate = nextState(state, k); + if (!vis[nstate]){ + Q.push(nstate); + vis[nstate] = true; + prestate[nstate] = state; + prechar[nstate] = k; + } + } + } + if (-1 == ans){ + printf("Case #%d: 0\n", ++ca); + continue; + } + string ts; + while (ans != 0){ + ts.push_back(char('a' + prechar[ans])); + ans = prestate[ans]; + } + reverse(ts.begin(), ts.end()); + printf("Case #%d: %s\n", ++ca, ts.c_str()); + } + return 0; +} diff --git a/HDOJ/5489_autoAC.cpp b/HDOJ/5489_autoAC.cpp new file mode 100644 index 0000000..7b79094 --- /dev/null +++ b/HDOJ/5489_autoAC.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +using namespace std ; +const int maxn = 1e5+10 ; +int a[maxn] , b[maxn] ; +int c[maxn] ; +pair pre[maxn] ; +int len_b = 0 ; +int len_a = 0 ; +int find_b(int l , int r , int v) +{ + while(l<=r) + { + int mid = (l+r)>> 1 ; + if(b[mid]>=v) + l = mid+1 ; + else r = mid - 1 ; + } + return l; +} +int find_a(int l , int r ,int v) +{ + while(l<=r) + { + int mid = (l + r) >> 1 ; + if(a[mid]<=v) + l = mid+1 ; + else r = mid - 1 ; + } + return l ; +} +int find_ans_a(int l , int r , int v) +{ + while(l<=r) + { + int mid = (l+r)>>1 ; + if(a[mid]<=v) + l = mid + 1 ; + else r = mid - 1 ; + } + return r ; +} +int find_ans_b(int l , int r , int v) +{ + while(l<=r) + { + int mid = (l+r) >> 1 ; + if(b[mid] >= v) + l = mid + 1 ; + else r = mid - 1 ; + } + return r ; +} +void debuga() +{ + for(int i = 1;i <= len_a;i++) + printf("%d%c" , a[i] , i == len_ ?'\n' :' ') ; +} +int main() +{ + int t ; + scanf("%d" , &t) ; + int cas = 0 ; + while(t--) + { + int n , l ; + scanf("%d%d" , &n , &l) ; + for(int i = 1;i <= n;i++) + a[i] = b[i] = 0 ; + for(int i = 1;i <= n;i++) + scanf("%d" , &c[i]) ; + len_a = len_b = 0 ; + for(int j = n;j > l;j--) + { + int pos = find_b(1 , len_ , c[j]) ; + pre[j] = make_pair(pos , b[pos]) ; + if(!b[pos])len_b++ ; + b[pos] = c[j] ; + } + int ans = len_ ; + for(int i = 1;i <= n-l;i++) + { + int pos = find_a(1 , len_ , c[i]) ; + if(a[pos] == 0)len_a++ ; + a[pos] = c[i] ; + pair tmp = pre[i+l] ; + if(tmp.second == 0)len_b--; + else b[tmp.first] = tmp.second ; + int pos_1 = find_ans_b(1 , len_ , c[i]) ; + ans = max(pos+pos_ , ans) ; + if(tmp.second != 0) + { + int pos_2 = find_ans_a(1 , len_ , tmp.second) ; + ans = max(ans , pos_2 + tmp.first) ; + } + } + printf("Case #%d: " , ++cas) ; + printf("%d\n" , ans) ; + } + return 0 ; +} diff --git a/HDOJ/5490_autoAC.cpp b/HDOJ/5490_autoAC.cpp new file mode 100644 index 0000000..5bb2d3c --- /dev/null +++ b/HDOJ/5490_autoAC.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +#define LL long long +#define MOD 1000000007 +using namespace std; +LL b1, q, a1, d, n, m; +LL ans, dis[10005]; +void input() +{ + ans = 0; + scanf("%I64d%I64d%I64d%I64d%I64d%I64d", &b1, &q, &a1, &d, &n, &m); +} +void exgcd(LL a, LL b, LL &x, LL &y, LL &d) +{ + if (b == 0) + { + x = 1; + y = 0; + d = a; + } + else + { + exgcd(b, a%b, y, x, d); + y -= a/b*x; + } +} +LL modDiv(LL a, LL b) +{ + LL x, y, d; + exgcd(b, MOD, x, y, d); + x = (x+MOD) % MOD; + x = (x*a/d) % MOD; + return x; +} +LL quickPow(LL x, LL n) +{ + LL a = 1; + while (n) + { + a *= n&1 ? x : 1; + a %= MOD; + n >>= 1 ; + x *= x; + x %= MOD; + } + return a; +} +void work() +{ + LL now = b1, tmp; + now %= MOD; + for (int i = 1; i <= n; ++i) + { + tmp = modDiv(now, q-1); + now = now+tmp; + now %= MOD; + dis[i] = (a1+(i-1)*d%MOD-tmp)%MOD; + dis[i] = (dis[i]+MOD)%MOD; + } + LL qt = 1; + ans += qt*dis[n]; + for (int i = n-1; i > 0; --i) + { + qt = modDiv((qt*((n+m-1)-i)%MOD+MOD)%MOD, n-i); + ans += (qt*dis[i])%MOD; + ans %= MOD; + } + tmp = quickPow(q, (m-1)%(MOD-1))%MOD; + ans += now*tmp%MOD; + ans %= MOD; + printf("%I64d\n", ans); +} +int main() +{ + int T; + scanf("%d", &T); + for (int times = 1; times <= T; ++times) + { + printf("Case #%d: ", times); + input(); + work(); + } + return 0; +} diff --git a/HDOJ/5491_autoAC.cpp b/HDOJ/5491_autoAC.cpp new file mode 100644 index 0000000..ef823ce --- /dev/null +++ b/HDOJ/5491_autoAC.cpp @@ -0,0 +1,112 @@ +#pragma comment(linker, "/STACK:1024000000,1024000000") +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 300006 +#define mod 1000000007 +#define eps 1e-9 +#define e exp(1.0) +#define PI acos(-1) +const double EP = 1E-10 ; +int Num; +const ll inf=999999999; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +int get(ll x) +{ + int c =0 ; + while (x >0) + { + if((x &1) ==1) + c++; ; + x >>=1 ; + } + return c ; +} +ll change(ll x,int num) +{ + for(int i=0;i<132;i++) + { + if((x&(1LL<=0;i--) + { + x-=(1LL<P*2)return P; + return x; +} +int main() +{ + int t;scanf("%d",&t); + for(int cas = 1;cas <= t;cas ++) + { + ll a=read(),s1=read(),s2=read(); + ll ans = a+1; + printf("Case #%d: ",cas); + int len = get(ans); + if(len<=s2&&len>=s1) + { + printf("%I64d\n",ans); + continue; + } + if(lens2) + { + while(len>s2) + { + ans = change2(ans,len,s1,a); + len = get(ans); + } + printf("%I64d\n",ans); + } + } +} diff --git a/HDOJ/5492_autoAC.cpp b/HDOJ/5492_autoAC.cpp new file mode 100644 index 0000000..8f61e01 --- /dev/null +++ b/HDOJ/5492_autoAC.cpp @@ -0,0 +1,97 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef unsigned char byte; +#define pb push_back +#define input_fast std::ios::sync_with_stdio(false);std::cin.tie(0) +#define pi acos(-1) +using namespace std; +const int maxn = 30 + 10; +int dp[maxn][maxn][2000]; +int g[maxn][maxn] , n , m , px ,dir[2][2] = {0,1,1,0},tans; +int cal(int x,int y) +{ + return px*x - y*y; +} +bool inmap(int x,int y) +{ + return x <= n && x >= 1 && y <= m && y >= 1; +} +void initiation() +{ + tans = 1 << 29; + scanf("%d%d",&n,&m); + for(int i = 1 ; i <= n ; ++ i) + for(int j = 1 ; j <= m ; ++ j) + scanf("%d",&g[i][j]); + px = n + m - 1; + memset(dp,-1,sizeof(dp)); + dp[1][1][g[1][1]] = g[1][1]*g[1][1]; +} +void updata(int &x ,int v) +{ + if(x==-1) x=v; + else x = min(x,v); +} +int solve() +{ + for(int i = 1 ; i <= n ; ++ i) + for(int j = 1 ; j <= m ; ++ j) + { + for(int z = 0 ; z <= 1900 ; ++ z) + { + if(dp[i][j][z] == -1) continue; + for(int k = 0 ; k < 2 ; ++ k) + { + int newx = i + dir[k][0]; + int newy = j + dir[k][1]; + if(!inmap(newx,newy)) continue; + int newval = dp[i][j][z] + g[newx][newy]*g[newx][newy]; + updata(dp[newx][newy][z+g[newx][newy]],newval); + } + } + } + int ans = 1 << 30; + for(int i = 0 ; i <= 1900 ; ++ i) if(dp[n][m][i] != -1) ans = min(ans , px*dp[n][m][i] - i*i); + return ans; +} +void dfs(int x,int y,int s1,int s2) +{ + if(x==n&&y==m) + { + tans =min(tans,s1*px-s2*s2); + } + else + { + for(int k = 0 ; k < 2 ; ++ k) + { + int newx = x + dir[k][0]; + int newy = y + dir[k][1]; + if(!inmap(newx,newy)) continue; + dfs(newx,newy,s1+g[newx][newy]*g[newx][newy],s2+g[newx][newy]); + } + } +} +int main(int argc,char *argv[]) +{ + int Case,cas=1; + scanf("%d",&Case); + while(Case--) + { + initiation(); + printf("Case #%d: %d\n",cas++,solve()); + } + return 0; +} diff --git a/HDOJ/5493_autoAC.cpp b/HDOJ/5493_autoAC.cpp new file mode 100644 index 0000000..a08e641 --- /dev/null +++ b/HDOJ/5493_autoAC.cpp @@ -0,0 +1,132 @@ +#pragma comment(linker, "/STACK:1024000000,1024000000") +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 200006 +#define mod 1000000007 +#define eps 1e-9 +#define e exp(1.0) +#define PI acos(-1) +#define lowbit(x) (x)&(-x) +const double EP = 1E-10 ; +int Num; +const ll inf=999999999; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +int n,val1[maxn],val2[maxn]; +void add(int * vc,int u ,int v) +{ + while(u <= n ) + { + vc[u] += v; + u += lowbit(u); + } +} +int query(int * vc,int u) +{ + int res=0; + while(u) + { + res += vc[u]; + u -= lowbit(u); + } + return res; +} +int RankGet(int * vc,int k) +{ + int L = 1 , R = n; + while(L < R) + { + int mid = L + ((R-L)>>1); + int res = query(vc,mid); + if(res == k) R = mid; + else if(res < k) L = mid + 1; + else R = mid - 1; + } + return L; +} +struct kkk +{ + int x,y; +}; +bool cmp(kkk aa,kkk bb) +{ + return aa.x v1,v2; +int main() +{ + int t=read(); + for(int cas=1;cas<=t;cas++) + { + n=read(); + for(int i=1;i<=n;i++) + { + p[i].x=read(),p[i].y=read(); + p[i].y++; + } + sort(p+1,p+n+1,cmp); + int flag=1; + memset(val1,0,4*(n+2));memset(val2,0,4*(n+2)); + for(int i = 1 ; i <= n ; ++ i) + { + add(val1,i,1); + add(val2,i,1); + } + for(int i=1;i<=n;i++) + { + if(p[i].y>n-i+1) + { + flag=0; + break; + } + int p1 = RankGet(val1,p[i].y); + int p2 = n-RankGet(val2,p[i].y) + 1; + if(p1 +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-6; +const double pi = acos(-1.0); +const int INF = 0x3f3f3f3f; +const int MOD = 1000000007; +#define ll long long +#define CL(a) memset(a,0,sizeof(a)) +int main () +{ + int T,n,m; + int a[1111],b[1111]; + cin>>T; + while (T--) + { + cin>>n>>m; + for (int i=0; i>a[i]; + for (int i=0; i>b[i]; + sort(a, a+n); + sort(b, b+n); + int suma=0,sumb=0; + for (int i=1; i<=m; i++) + { + suma+=a[i-1]; + sumb+=b[n-i]; + } + if (suma>sumb) + cout<<"YES"< +#include +#include +#include +using namespace std; +#define maxn 100007 +int a[maxn],b[maxn],vis[maxn]; +int dfs(int x){ + vis[x] = 1; + if(vis[b[a[x]]]) return 1; + return dfs(b[a[x]])+1; +} +int main(){ + int t,n,u; + scanf("%d",&t); + while(t--){ + scanf("%d",&n); + for(int i = 1;i <= n; i++){ + scanf("%d",&u); + a[u] = i; + } + for(int i = 1;i <= n; i++) + scanf("%d",&b[i]); + memset(vis,0,sizeof(vis)); + int ans = n; + for(int i = 1;i <= n; i++){ + if(vis[i] == 0) { + if(dfs(i) > 1) ans--; + } + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/5496_autoAC.cpp b/HDOJ/5496_autoAC.cpp new file mode 100644 index 0000000..30e1597 --- /dev/null +++ b/HDOJ/5496_autoAC.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const LL mod = 1000000007; +const int maxn = 100005; +int b[maxn],a[maxn]; +int n,m; +LL cnt[maxn]; +LL B[maxn]; +int main() { + int t; + cin >> t; + B[0] = 1; + for (int i = 1;i < maxn;i++) B[i] = (B[i - 1] * 2) % mod; + while (t--) { + memset(cnt, 0, sizeof(cnt)); + cin >> n; + for (int i = 0;i < n;i++) { + scanf("%d", &a[i]); + b[i] = a[i]; + } + sort(b, b + n); + m = unique(b, b + n) - b; + LL ret = 0; + for (int i = 0;i < n;i++) { + int x = lower_bound(b, b + m, a[i]) - b; + ret = ((ret - ((cnt[x] * (LL)a[i]) % mod * B[n - i - 1])%mod)%mod+mod)%mod; + ret = (ret + B[n - 1] * (LL)a[i]) % mod; + cnt[x] = (cnt[x] + B[i])%mod; + } + cout << ret << endl; + } + return 0; +} diff --git a/HDOJ/5497_autoAC.cpp b/HDOJ/5497_autoAC.cpp new file mode 100644 index 0000000..64e126a --- /dev/null +++ b/HDOJ/5497_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define pr(x) cout << #x << " = " << x << " " +#define prln(x) cout << #x << " = " << x << endl +const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7; +int n, m, a[N], b[N], c[N]; +void add(int *b, int i, int v) { + for(; i <= n; i += i & -i) b[i] += v; +} +int sum(int *b, int i) { + int ret = 0; + for(; i; i -= i & -i) ret += b[i]; + return ret; +} +inline int read() { + int c, x; + while(c = getchar(), !isdigit(c)); + x = c - '0'; + while(c = getchar(), isdigit(c)) x = x * 10 + c - '0'; + return x; +} +int main() { + ios_base::sync_with_stdio(0); + int t; t = read(); + while(t--) { + n = read(); m = read(); + for(int i = 1; i <= n; ++i) a[i] = read(); + memset(b, 0, sizeof b); + memset(c, 0, sizeof c); + long long tmp = 0; + for(int i = m + 1; i <= n; ++i) { + tmp += i - m - 1 - sum(c, a[i]); + add(c, a[i], 1); + } + long long ans = tmp; + for(int i = m + 1; i <= n; ++i) { + tmp -= sum(c, a[i] - 1); + tmp -= sum(b, n) - sum(b, a[i]); + add(c, a[i], -1); + tmp += sum(c, a[i - m] - 1); + tmp += sum(b, n) - sum(b, a[i - m]); + add(b, a[i - m], 1); + ans = min(ans, tmp); + } + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5498_autoAC.cpp b/HDOJ/5498_autoAC.cpp new file mode 100644 index 0000000..71c5a3d --- /dev/null +++ b/HDOJ/5498_autoAC.cpp @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include +using namespace std; +#define ll long long +#define maxn 101 +int p; +struct Node{ + int mat[maxn][maxn]; + void init(){ + memset(mat,0,sizeof(mat)); + } + void one(int n){ + init(); + for(int i = 0;i < n; i++) + mat[i][i] = 1; + } + int Det(int n, int mod1){ + int ans = 1; + int *p1,*p2,mul; + for(int i = 0;i < n; i++){ + for(int j = i+1;j < n; j++){ + while(mat[i][i] != 0 && mat[j][i] != 0){ + if(abs(mat[i][i]) > abs(mat[j][i])) + p1=mat[i],p2=mat[j],mul=mat[i][i]/mat[j][i]; + else + p1=mat[j],p2=mat[i],mul=mat[j][i]/mat[i][i]; + for(int l = i;l < n; l++) + p1[l] = (p1[l]-(ll)p2[l]*mul)%mod1; + } + if(mat[i][i] == 0){ + ans = -ans; + for(int l = i;l < n;l++) + swap(mat[i][l],mat[j][l]); + } + } + ans = (ll)ans*mat[i][i] % mod1; + } + return (ans+mod1)%mod1; + } +}; +int matrix[maxn][maxn]; +void multi(Node& a,Node& b,int n){ + for(int i = 0;i < n; i++) + for(int j = 0;j < n; j++) + matrix[i][j] = 0; + for(int i = 0;i < n; i++){ + for(int j = 0;j < n; j++){ + if(a.mat[i][j] == 0) continue; + for(int k = 0;k < n; k++){ + if(b.mat[j][k] == 0) continue; + matrix[i][k] = (matrix[i][k]+(ll)a.mat[i][j]*b.mat[j][k])%p; + } + } + } + for(int i = 0;i < n; i++) + for(int j = 0;j < n; j++) + a.mat[i][j] = matrix[i][j]; +} +int mp[maxn][maxn]; +int main(){ + int t,n,m,q,u,v; + Node a,b,c; + scanf("%d",&t); + while(t--){ + scanf("%d%d%d%d",&n,&m,&p,&q); + c.init(); + for(int i = 0;i < m; i++){ + scanf("%d%d",&u,&v); + u--,v--; + c.mat[u][u]++; + c.mat[v][v]++; + c.mat[u][v] = c.mat[v][u] = -1; + } + if(q < n-1){ + printf("0\n"); + continue; + } + int ans = c.Det(n-1,p); + if(ans == 0){ + printf("0\n"); + continue; + } + a.init(); + b.one(n); + for(int i = 1;i < n; i++) + a.mat[i][i] = i,a.mat[i][i-1] = n-i; + while(q){ + if(q&1) multi(b,a,n); + multi(a,a,n); + q/=2; + } + ans = (ll)ans*b.mat[n-1][0]%p; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/5499_autoAC.cpp b/HDOJ/5499_autoAC.cpp new file mode 100644 index 0000000..3780348 --- /dev/null +++ b/HDOJ/5499_autoAC.cpp @@ -0,0 +1,68 @@ +#include +#include +#include +#include +#include +using namespace std; +#define maxn 110 +class node +{ +public: + string sex,name; + double sum; + int r1,r2; + void set(string n,string s,int o,int t) + { + sex=s,name=n; + r1=o,r2=t; + } +}male[maxn],fe[maxn],ans[maxn]; +bool cmp(node x,node y) +{ + return x.sum>y.sum; +} +int main() +{ + int T; + cin>>T; + while(T--) + { + int n,m; + cin>>n>>m; + string name,sex; + int r1,r2,rr1=0,rr2=0; + int f=0,p=0,top=0; + for(int i=0;i>name>>sex>>r1>>r2; + rr1=max(rr1,r1); + rr2=max(rr2,r2); + if(sex=="male") male[p++].set(name,sex,r1,r2); + else fe[f++].set(name,sex,r1,r2); + } + double m1,m2; + m1=300*1.0/rr1,m2=300*1.0/rr2; + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define N 300005 +#define NMAX 2000000000 +typedef long long ll; +int a[22]; +bool cmp(const int& x, const int& y){ + return x>y; +} +int main(){ + int T, n, m; + while ( scanf("%d", &T) != EOF){ + while ( T > 0 ){ + T--; + scanf("%d", &n); + int index = -1; + for ( int i = 0 ;i < n; i++ ){ + scanf("%d", &a[i]); + } + int ans = 0, t = n - 1, cur = n; + while ( t >= 0 ){ + if ( a[t] == cur ) cur--; + t--; + } + cout << cur << endl; + } + } + return 0; +} diff --git a/HDOJ/5501_autoAC.cpp b/HDOJ/5501_autoAC.cpp new file mode 100644 index 0000000..a8a8c61 --- /dev/null +++ b/HDOJ/5501_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define eps 1e-5 +#define INF 0x7fffffff +#define FOR(i,a) for((i)=0;i<(a);(i)++) +#define MEM(a) (memset((a),0,sizeof(a))) +#define sfs(a) scanf("%s",a) +#define sf(a) scanf("%d",&a) +#define sfI(a) scanf("%I64d",&a) +#define pf(a) printf("%d\n",a) +#define pfI(a) printf("%I64d\n",a) +#define pfs(a) printf("%s\n",a) +#define sfd(a,b) scanf("%d%d",&a,&b) +#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num) +#define for1(i,a,b) for(int i=(a);i=a;i--) +#define MEM1(a) memset(a,0,sizeof(a)) +#define MEM2(a) memset(a,-1,sizeof(a)) +#define ll long long +const double PI=acos(-1.0); +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;} +template inline T Min(T a,T b){return a inline T Max(T a,T b){return a>b?a:b;} +using namespace std; +int n,m,L; +#define N 50005 +#define M 1000100 +#define Mod 1000000007 +#define p(x,y) make_pair(x,y) +int dp[5010]; +struct Node{ + int a,b,c; + bool operator <(const Node &x) const{ + return (ll)b*x.c>(ll)x.b*c; + } +}e[1010]; +int main(){ + int T; + sf(T); + while(T--){ + int t; + sfd(n,t); + for(int i=1;i<=n;i++){ + scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].c); + } + sort(e+1,e+n+1); + memset(dp,0,sizeof dp); + for(int i=1;i<=n;i++){ + for(int j=t;j>=e[i].c;j--){ + dp[j] = Max(dp[j],dp[j-e[i].c]+Max(0,e[i].a-j*e[i].b)); + } + } + int ans=-INF; + for(int i=0;i<=t;i++) + ans = Max(ans,dp[i]); + pf(ans); + } + return 0; +} diff --git a/HDOJ/5502_autoAC.cpp b/HDOJ/5502_autoAC.cpp new file mode 100644 index 0000000..db3c7bd --- /dev/null +++ b/HDOJ/5502_autoAC.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include +using namespace std; +double dp[1550]; +double power[1550]; +double ans[1550]; +double pre[1550]; +int main(){ + int T,n; + double p,q; + scanf("%d",&T); + while(T--){ + scanf("%d%lf%lf",&n,&p,&q); + power[0]=1; + double pro0=q/p; + double pro1=(p-q)/p; + for(int i=1;i<=n+1;i++){ + power[i]=power[i-1]*pro0; + } + ans[0]=0; + n++; + for(int i=1;i<=n;i++){ + dp[0]=pre[0]=1; + for(int j=1;j<=n;j++){ + double now=pre[j-1]; + if(j-1-i>=0) now-=pre[j-1-i]*power[i]; + dp[j]=now*pro1; + pre[j]=pre[j-1]*pro0+dp[j]; + } + ans[i]=dp[n]; + } + double e=0; + for(int i=n;i>=1;i--){ + e+=(ans[i]-ans[i-1])*i; + } + e/=pro1; + printf("%.3lf\n",e); + } + return 0; +} diff --git a/HDOJ/5503_autoAC.cpp b/HDOJ/5503_autoAC.cpp new file mode 100644 index 0000000..06df29b --- /dev/null +++ b/HDOJ/5503_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +using namespace std; +#define LL long long +#define N 50007 +LL c[N], s[N]; +void init() { + for (LL i = 1; i < N; ++i) + c[i] = i * (i - 1) >> 1; +} +inline int read() { + int ret = 0; + char ch = getchar(); + while (!('0' <= ch && ch <= '9')) + ch = getchar(); + while ('0' <= ch && ch <= '9') { + ret = ret * 10 + ch - '0'; + ch = getchar(); + } + return ret; +} +int main() { + init(); + int T = read(); + int n, i; + LL sum; + bool flag; + while (T--) { + n = read(); + for (i = 0; i < n; ++i) + s[i] = read(); + sort(s, s + n); + sum = 0; + flag = true; + for (i = 1; i <= n; ++i) { + sum = sum + s[i - 1]; + if (sum < c[i]) { + flag = false; + break; + } + } + if (sum != c[n]) + flag = false; + if (flag) + puts("It seems to have no problem."); + else + puts("The data have been tampered with!"); + } + return 0; +} diff --git a/HDOJ/5504_autoAC.cpp b/HDOJ/5504_autoAC.cpp new file mode 100644 index 0000000..eb41b31 --- /dev/null +++ b/HDOJ/5504_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-6; +const double pi = acos(-1.0); +const int INF = 0x3f3f3f3f; +const int MOD = 1000000007; +#define ll long long +#define CL(a) memset(a,0,sizeof(a)) +int main() +{ + int T; + ll n,x,sum; + cin>>T; + while(T--) + { + cin>>n; + sum = 0; + int k=0,re=0; + ll maxx = -INF; + for(int i=0; i>x; + if(x == 0) {re++; continue;} + if(x < 0) + { + k++; + maxx = max(maxx, x); + } + if(i == re) sum = x; + else sum *= x; + } + if(k%2&&n!=1&&!(k==1&&re+k==n)) sum /= maxx; + if(re>0&&(sum<0||n==1)) sum = 0; + cout<