From ff9985fa259d8c6bcbf943db3579082a782b4f47 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Sun, 4 Sep 2016 14:14:07 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 3700-3799 --- HDOJ/3700_autoAC.cpp | 167 +++++++++++++++++++++ HDOJ/3706_autoAC.cpp | 28 ++++ HDOJ/3709_autoAC.cpp | 54 +++++++ HDOJ/3710_autoAC.cpp | 346 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/3711_autoAC.cpp | 61 ++++++++ HDOJ/3712_autoAC.cpp | 89 +++++++++++ HDOJ/3713_autoAC.cpp | 110 ++++++++++++++ HDOJ/3714_autoAC.cpp | 50 +++++++ HDOJ/3715_autoAC.cpp | 147 ++++++++++++++++++ HDOJ/3716_autoAC.cpp | 68 +++++++++ HDOJ/3717_autoAC.cpp | 51 +++++++ HDOJ/3718_autoAC.cpp | 138 +++++++++++++++++ HDOJ/3719_autoAC.cpp | 267 +++++++++++++++++++++++++++++++++ HDOJ/3720_autoAC.cpp | 81 ++++++++++ HDOJ/3721_autoAC.cpp | 100 +++++++++++++ HDOJ/3722_autoAC.cpp | 110 ++++++++++++++ HDOJ/3724_autoAC.cpp | 114 ++++++++++++++ HDOJ/3725_autoAC.cpp | 112 ++++++++++++++ HDOJ/3726_autoAC.cpp | 240 ++++++++++++++++++++++++++++++ HDOJ/3727_autoAC.cpp | 124 ++++++++++++++++ HDOJ/3729_autoAC.cpp | 58 ++++++++ HDOJ/3730_autoAC.cpp | 33 +++++ HDOJ/3732_autoAC.cpp | 45 ++++++ HDOJ/3734_autoAC.cpp | 53 +++++++ HDOJ/3735_autoAC.cpp | 93 ++++++++++++ HDOJ/3738_autoAC.cpp | 54 +++++++ HDOJ/3739_autoAC.cpp | 110 ++++++++++++++ HDOJ/3741_autoAC.cpp | 72 +++++++++ HDOJ/3742_autoAC.cpp | 40 +++++ HDOJ/3743_autoAC.cpp | 56 +++++++ HDOJ/3744_autoAC.cpp | 49 ++++++ HDOJ/3746_autoAC.cpp | 42 ++++++ HDOJ/3747_autoAC.cpp | 33 +++++ HDOJ/3748_autoAC.cpp | 114 ++++++++++++++ HDOJ/3749_autoAC.cpp | 163 ++++++++++++++++++++ HDOJ/3750_autoAC.cpp | 23 +++ HDOJ/3752_autoAC.cpp | 17 +++ HDOJ/3753_autoAC.cpp | 40 +++++ HDOJ/3754_autoAC.cpp | 65 ++++++++ HDOJ/3756_autoAC.cpp | 61 ++++++++ HDOJ/3757_autoAC.cpp | 74 +++++++++ HDOJ/3758_autoAC.cpp | 133 +++++++++++++++++ HDOJ/3759_autoAC.cpp | 242 ++++++++++++++++++++++++++++++ HDOJ/3760_autoAC.cpp | 120 +++++++++++++++ HDOJ/3761_autoAC.cpp | 88 +++++++++++ HDOJ/3763_autoAC.cpp | 40 +++++ HDOJ/3764_autoAC.cpp | 31 ++++ HDOJ/3765_autoAC.cpp | 43 ++++++ HDOJ/3766_autoAC.cpp | 45 ++++++ HDOJ/3767_autoAC.cpp | 38 +++++ HDOJ/3768_autoAC.cpp | 92 ++++++++++++ HDOJ/3772_autoAC.cpp | 100 +++++++++++++ HDOJ/3774_autoAC.cpp | 27 ++++ HDOJ/3775_autoAC.cpp | 27 ++++ HDOJ/3776_autoAC.cpp | 91 ++++++++++++ HDOJ/3777_autoAC.cpp | 77 ++++++++++ HDOJ/3778_autoAC.cpp | 146 ++++++++++++++++++ HDOJ/3779_autoAC.cpp | 37 +++++ HDOJ/3780_autoAC.cpp | 52 +++++++ HDOJ/3781_autoAC.cpp | 110 ++++++++++++++ HDOJ/3782_autoAC.cpp | 20 +++ HDOJ/3783_autoAC.cpp | 46 ++++++ HDOJ/3784_autoAC.cpp | 54 +++++++ HDOJ/3785_autoAC.cpp | 70 +++++++++ HDOJ/3786_autoAC.cpp | 94 ++++++++++++ HDOJ/3787_autoAC.cpp | 33 +++++ HDOJ/3788_autoAC.cpp | 38 +++++ HDOJ/3789_autoAC.cpp | 121 +++++++++++++++ HDOJ/3790_autoAC.cpp | 80 ++++++++++ HDOJ/3791_autoAC.cpp | 88 +++++++++++ HDOJ/3792_autoAC.cpp | 43 ++++++ HDOJ/3793_autoAC.cpp | 48 ++++++ HDOJ/3794_autoAC.cpp | 34 +++++ 73 files changed, 6060 insertions(+) create mode 100644 HDOJ/3700_autoAC.cpp create mode 100644 HDOJ/3706_autoAC.cpp create mode 100644 HDOJ/3709_autoAC.cpp create mode 100644 HDOJ/3710_autoAC.cpp create mode 100644 HDOJ/3711_autoAC.cpp create mode 100644 HDOJ/3712_autoAC.cpp create mode 100644 HDOJ/3713_autoAC.cpp create mode 100644 HDOJ/3714_autoAC.cpp create mode 100644 HDOJ/3715_autoAC.cpp create mode 100644 HDOJ/3716_autoAC.cpp create mode 100644 HDOJ/3717_autoAC.cpp create mode 100644 HDOJ/3718_autoAC.cpp create mode 100644 HDOJ/3719_autoAC.cpp create mode 100644 HDOJ/3720_autoAC.cpp create mode 100644 HDOJ/3721_autoAC.cpp create mode 100644 HDOJ/3722_autoAC.cpp create mode 100644 HDOJ/3724_autoAC.cpp create mode 100644 HDOJ/3725_autoAC.cpp create mode 100644 HDOJ/3726_autoAC.cpp create mode 100644 HDOJ/3727_autoAC.cpp create mode 100644 HDOJ/3729_autoAC.cpp create mode 100644 HDOJ/3730_autoAC.cpp create mode 100644 HDOJ/3732_autoAC.cpp create mode 100644 HDOJ/3734_autoAC.cpp create mode 100644 HDOJ/3735_autoAC.cpp create mode 100644 HDOJ/3738_autoAC.cpp create mode 100644 HDOJ/3739_autoAC.cpp create mode 100644 HDOJ/3741_autoAC.cpp create mode 100644 HDOJ/3742_autoAC.cpp create mode 100644 HDOJ/3743_autoAC.cpp create mode 100644 HDOJ/3744_autoAC.cpp create mode 100644 HDOJ/3746_autoAC.cpp create mode 100644 HDOJ/3747_autoAC.cpp create mode 100644 HDOJ/3748_autoAC.cpp create mode 100644 HDOJ/3749_autoAC.cpp create mode 100644 HDOJ/3750_autoAC.cpp create mode 100644 HDOJ/3752_autoAC.cpp create mode 100644 HDOJ/3753_autoAC.cpp create mode 100644 HDOJ/3754_autoAC.cpp create mode 100644 HDOJ/3756_autoAC.cpp create mode 100644 HDOJ/3757_autoAC.cpp create mode 100644 HDOJ/3758_autoAC.cpp create mode 100644 HDOJ/3759_autoAC.cpp create mode 100644 HDOJ/3760_autoAC.cpp create mode 100644 HDOJ/3761_autoAC.cpp create mode 100644 HDOJ/3763_autoAC.cpp create mode 100644 HDOJ/3764_autoAC.cpp create mode 100644 HDOJ/3765_autoAC.cpp create mode 100644 HDOJ/3766_autoAC.cpp create mode 100644 HDOJ/3767_autoAC.cpp create mode 100644 HDOJ/3768_autoAC.cpp create mode 100644 HDOJ/3772_autoAC.cpp create mode 100644 HDOJ/3774_autoAC.cpp create mode 100644 HDOJ/3775_autoAC.cpp create mode 100644 HDOJ/3776_autoAC.cpp create mode 100644 HDOJ/3777_autoAC.cpp create mode 100644 HDOJ/3778_autoAC.cpp create mode 100644 HDOJ/3779_autoAC.cpp create mode 100644 HDOJ/3780_autoAC.cpp create mode 100644 HDOJ/3781_autoAC.cpp create mode 100644 HDOJ/3782_autoAC.cpp create mode 100644 HDOJ/3783_autoAC.cpp create mode 100644 HDOJ/3784_autoAC.cpp create mode 100644 HDOJ/3785_autoAC.cpp create mode 100644 HDOJ/3786_autoAC.cpp create mode 100644 HDOJ/3787_autoAC.cpp create mode 100644 HDOJ/3788_autoAC.cpp create mode 100644 HDOJ/3789_autoAC.cpp create mode 100644 HDOJ/3790_autoAC.cpp create mode 100644 HDOJ/3791_autoAC.cpp create mode 100644 HDOJ/3792_autoAC.cpp create mode 100644 HDOJ/3793_autoAC.cpp create mode 100644 HDOJ/3794_autoAC.cpp diff --git a/HDOJ/3700_autoAC.cpp b/HDOJ/3700_autoAC.cpp new file mode 100644 index 0000000..47e5381 --- /dev/null +++ b/HDOJ/3700_autoAC.cpp @@ -0,0 +1,167 @@ +#include +#include +using namespace std; +#define N 21 +int n,sleep,awake; +struct Time +{ + int hour; + int minite; + int sec; + void trans() + { sec=hour*60+minite; } + void retrans() + { sec+=24*60; } + void minusonesecond() + { + if(minite==0) + hour--,minite=59; + else minite--; + if(hour<0) + hour+=24; + } + void addonesecond() + { + if(minite==59) + hour++,minite=0; + else minite++; + if(hour>23) + hour-=24; + } + bool operator < (const Time a)const + { + if(hour==a.hour) + { + return minitetbtb) + return 1; + return -1; +} +Time sle[N][2]; +char evn[20]; +void solve(bool flag) +{ + int i,j,begin,end,temp=0,nowlast=0,segn=0; + Time temp1,temp2; + for(i=2;i<=n;i++) + { + end=affire[i].tb.sec-1; + begin=affire[i-1].te.sec+1; + if(end=sleep) + { + ++segn; + temp1=affire[i-1].te; + temp1.addonesecond(); + sle[segn][0]=temp1; + temp1=affire[i].tb; + temp1.minusonesecond(); + sle[segn][1]=temp1; + nowlast=0; + } + else if(end-begin+1awake) + { + printf("No\n"); + return ; + } + } + } + end=affire[1].tb.sec-1; + begin=affire[n].te.sec+1; + if(end=sleep) + { + ++segn; + temp2=affire[n].te; + temp2.addonesecond(); + sle[segn][0]=temp2; + temp1=affire[1].tb; + temp1.minusonesecond(); + sle[segn][1]=temp1; + nowlast=0; + } + else if(end-begin+1awake) + { + printf("No\n"); + return ; + } + } + if(n==0) + { + segn=1; + printf("Yes\n%d\n",segn); + printf("00:00-23:59\n"); + return; + } + else + { + if(segn!=0) + { + printf("Yes\n%d\n",segn); + for(i=1;i<=segn;i++) + { + printf("%02d:%02d-%02d:%02d\n",sle[i][0].hour,sle[i][0].minite,sle[i][1].hour,sle[i][1].minite); + } + } + else + printf("No\n"); + } +} +int main() +{ + while(scanf("%d%d",&sleep,&awake)!=EOF) + { + sleep*=60,awake*=60; + scanf("%d",&n); + int i,j; + bool flag=false; + bool ss=false; + for(i=1;i<=n;i++) + { + Time T1,T2; + scanf("%d:%d-%d:%d",&T1.hour,&T1.minite,&T2.hour,&T2.minite); + T1.trans(),T2.trans(); + if(T2.sec-T1.sec+1>awake) + { + ss=true; + } + if(T2 +#include +#include +#include +#include +#define INF 0x7fffffff +using namespace std; +int main() +{ + int n,A,B; + int q[100001],id[100001]; + while(scanf("%d%d%d",&n,&A,&B)!=EOF) + { + __int64 Ti=1,s=1; + int head=0,tail=0; + for(int i=1;i<=n;i++) + { + s=(s*A)%B; + while(head=s) tail--; + q[++tail]=s; + id[tail]=i; + while(id[head+1] +#include +#include +using namespace std; +int bit[19]; +__int64 dp[19][19][2005]; +__int64 dfs(int pos,int o,int l,int work) +{ + if(pos == -1) + return l == 0; + if(l<0) + return 0; + if(!work && dp[pos][o][l]!=-1) + return dp[pos][o][l]; + __int64 ans = 0; + int end = work?bit[pos]:9; + for(int i=0; i<=end; i++) + { + int next = l; + next += (pos-o)*i; + ans+=dfs(pos-1,o,next,work&&i==end); + } + if(!work) + dp[pos][o][l] = ans; + return ans; +} +__int64 solve(__int64 n) +{ + int len = 0; + while(n) + { + bit[len++] = n%10; + n/=10; + } + __int64 ans = 0; + for(int i = 0; i +#include +#include +#include +#include +using namespace std; +const int N = 20005; +const int M = 100005; +const int QN = M; +const int INF = 0X7FFFFFFF; +typedef int vType; +typedef pair pii; +#define mkpii make_pair +struct e{ + int v; + e* nxt; +}es[N<<1], *fir[N]; +struct node{ + int ls, rs; + int l, r; + int id; + vType Min; + int mid() { return (l + r) >> 1; } +}nodes[N<<1]; +struct se{ + pii e; + int len; +}ses[M<<1], lea[M<<1]; +int n, en, qn, m; +vector qlca[N]; +vector nes[N]; +int par[N], fa[N]; +int ln, cnt; +int leaNum; +int sons[N], que[N], dep[N], id[N], st[N], ed[N], root[N], top[N], sNum[N]; +int ith[N], pMin[N], seg[N]; +vType iw[N]; +int tr; +inline void add_e(int u, int v){ + es[en].v = v; + es[en].nxt = fir[u]; + fir[u] = &es[en++]; +} +inline void newNode(int& id, int l, int r){ + nodes[cnt].ls = nodes[cnt].rs = -1; + nodes[cnt].l = l; + nodes[cnt].r = r; + nodes[cnt].Min = INF; + id = cnt++; +} +void build(int& id, int l, int r){ + newNode(id, l, r); + if(l >= r){ + nodes[id].id = seg[l]; + return ; + } + int mid = (l+r)>>1; + build(nodes[id].ls, l, mid); + build(nodes[id].rs, mid+1, r); +} +void initTree(){ + int l, r, u, v, i; + e* cur; + l = r = 0; + que[r++] = tr; + par[tr] = -1; + dep[tr] = 0; + while(l != r){ + u = que[l++]; + int g = 1; + for(cur = fir[u]; cur; cur = cur->nxt){ + if((v = cur->v) != par[u]){ + que[r++] = v; + par[v] = u; + dep[v] = dep[u]+1; + ith[v] = g++; + } + } + } + for(i = 1; i <= n; i++){ + sons[i] = 1; + sNum[i] = 0; + id[i] = -1; + } + for(i = r-1; i >= 0; i--){ + u = que[i]; + if(par[u] >= 0){ + sons[par[u]] += sons[u]; + sNum[par[u]]++; + } + } + l = r = 0; + que[r++] = tr; + ln = cnt = 0; + while(l != r){ + u = que[l++]; + st[ln] = dep[u]; + top[ln] = u; + while(u >= 0){ + id[u] = ln; + ed[ln] = dep[u]; + seg[dep[u]] = u; + int best; + for(cur = fir[u], best=-1; cur; cur = cur->nxt){ + if(id[v = cur->v] == -1){ + if(best == -1 || (best >= 0 && sons[v] > sons[best])){ + best = v; + } + } + } + if(best >= 0){ + for(cur = fir[u]; cur; cur = cur->nxt){ + if(id[v = cur->v] == -1 && best != v){ + que[r++] = v; + } + } + } + u = best; + } + root[ln] = -1; + build(root[ln], st[ln], ed[ln]); + ln++; + } +} +int qrylKthFar(int& id, int i, int k){ + if(nodes[id].l == nodes[id].r) return nodes[id].id; + int mid = nodes[id].mid(); + if(i - mid - 1 >= k) return qrylKthFar(nodes[id].rs, i, k); + else return qrylKthFar(nodes[id].ls, i, k); +} +int qryKthFar(int i, int k){ + int u = i, ri; + while(true){ + ri = id[u]; + if(dep[u] - st[ri] >= k){ + return qrylKthFar(root[ri], dep[u], k); + }else{ + k -= dep[u] - st[ri] + 1; + u = par[top[ri]]; + } + } +} +void inslMin(int& id, int ql, int qr, int mv){ + if(id == -1) return ; + if(ql <= nodes[id].l && nodes[id].r <= qr){ + if(nodes[id].Min > mv){ + nodes[id].Min = mv; + } + return; + } + if(nodes[id].l == nodes[id].r) return; + int mid = nodes[id].mid(); + if(ql <= mid){ + inslMin(nodes[id].ls, ql, qr, mv); + } + if(qr > mid){ + inslMin(nodes[id].rs, ql, qr, mv); + } +} +void insMin(int i, int k, vType mv){ + int b, u; + u = i; + while(true){ + b = id[u]; + if(dep[u]-st[b] >= k){ + inslMin(root[b], dep[u]-k, dep[u], mv); + return; + }else{ + inslMin(root[b], st[b], dep[u], mv); + k -= dep[u] - st[b] + 1; + u = par[top[b]]; + } + } +} +bool input(){ + scanf("%d%d", &n, &m); + int i, k, tn; + for(i = tn = 0; i < m; i++){ + scanf("%d%d%d%d", &ses[i].e.first, &ses[i].e.second, &ses[i].len, &k); + if(k == 1){ + ses[i].len = 0; + } + if(ses[i].e.first != ses[i].e.second){ + tn++; + } + } + m = tn; + return true; +} +inline bool cmp(se a, se b){ + return a.len < b.len; +} +int findFa(int u){ + int k = u; + while(k != fa[k]) k = fa[k]; + while(u != k){ + int tf = fa[u]; + fa[u] = k; + u = tf; + } + return k; +} +void merge(int u, int v){ + int fu, fv; + fu = findFa(u); + fv = findFa(v); + fa[fu] = fv; +} +int kruskal(int n, int m, int& leaNum, bool flag){ + int i, ans, k, u, v; + for(i = 1; i <= n; i++){ + fa[i] = i; + } + if(flag){ + for(i = 1; i <= n; i++){ + iw[i] = 0; + fir[i] = NULL; + } + en = leaNum = 0; + } + sort(ses, ses + m, cmp); + for(i = ans = 0, k = 1; k < n && i < m; i++){ + u = ses[i].e.first; + v = ses[i].e.second; + if(findFa(u) != findFa(v)){ + ans += ses[i].len; + k++; + merge(u, v); + if(flag){ + add_e(u, v); + add_e(v, u); + iw[u] += ses[i].len; + iw[v] += ses[i].len; + } + }else if(flag){ + lea[leaNum++] = ses[i]; + } + } + if (flag) { + for (; i < m; i++) { + lea[leaNum++] = ses[i]; + } + } + if(k < n) ans = INF; + return ans; +} +void handlelca(int u, int v, int anc, int len){ + if(u != anc && v != anc){ + int ku, kv; + ku = qryKthFar(u, dep[u] - dep[anc] - 1); + kv = qryKthFar(v, dep[v] - dep[anc] - 1); + se te; + te.e.first = ith[ku]; + te.e.second = ith[kv]; + te.len = len; + nes[anc].push_back(te); + } + if(dep[anc] + 2 <= dep[u]){ + insMin(u, dep[u] - dep[anc] - 2, len); + } + if(dep[anc] + 2 <= dep[v]){ + insMin(v, dep[v] - dep[anc] - 2, len); + } +} +int getlca(int u, int v){ +while(id[u] != id[v]){ +if(id[u] < id[v]) swap(u, v); +u = par[top[id[u]]]; +} +if(dep[u] < dep[v]) swap(u, v); +return v; +} +void lca(se* qs, int qn){ +int i; +for(i = 1; i <= n; i++){ +nes[i].clear(); +} +for(i = 0; i < qn; i++){ +int u, v, anc; +u = qs[i].e.first; +v = qs[i].e.second; +anc = getlca(u, v); +handlelca(v, u, anc, qs[i].len); +} +} +void getpMin(int& id, int mv){ + if(mv > nodes[id].Min){ + mv = nodes[id].Min; + } + if(nodes[id].l == nodes[id].r){ + pMin[nodes[id].id] = mv; + return; + } + getpMin(nodes[id].ls, mv); + getpMin(nodes[id].rs, mv); +} +void getpMin(){ + int i; + for(i = 0; i < ln; i++){ + getpMin(root[i], INF); + } +} +void solve(){ + tr = 1; + int sum, i, sn, v, num; + e* cur; + sum = kruskal(n, m, leaNum, true); + initTree(); + lca(lea, leaNum); + getpMin(); + for(i = 1; i <= n; i++){ + num = 0; + sn = sNum[i]; + if (par[i] >= 1) { + sn++; + for (cur = fir[i]; cur; cur = cur->nxt) { + if ((v = cur->v) != par[i] && pMin[v] < INF) { + ses[num].e.first = sn; + ses[num].e.second = ith[v]; + ses[num].len = pMin[v]; + num++; + } + } + } + int size = nes[i].size(), j; + for(j = 0; j < size; j++){ + ses[num++] = nes[i][j]; + } + int ans = kruskal(sn, num, leaNum, false); + if(ans < INF){ + ans += sum - iw[i]; + printf("%d\n", ans); + }else{ + printf("inf\n"); + } + } +} +int main() { + int t; + scanf("%d", &t); + while(t--){ + input(); + solve(); + } + return 0; +} diff --git a/HDOJ/3711_autoAC.cpp b/HDOJ/3711_autoAC.cpp new file mode 100644 index 0000000..dc3408b --- /dev/null +++ b/HDOJ/3711_autoAC.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 101; +const int INF = 0x3f3f3f3f; +int n, m; +int a[maxn]; +int cal(int a, int b) +{ + int M = a ^ b; + int num = 0; + while(M) + { + M &= (M-1); + num++; + } + return num; +} +int get_ans(int t) +{ + int min = INF, num = 0, ans; + for(int i = 0; i < n; i++) + { + num = cal(a[i], t); + if(num < min) { min = num; ans = a[i]; } + } + return ans; +} +void read_case() +{ + scanf("%d%d", &n, &m); + for(int i = 0; i < n; i++) scanf("%d", &a[i]); + sort(a, a+n); +} +void solve() +{ + read_case(); + int t; + while(m--) + { + scanf("%d", &t); + int ans = get_ans(t); + printf("%d\n", ans); + } +} +int main() +{ + int T; + scanf("%d", &T); + while(T--) + { + solve(); + } + return 0; +} diff --git a/HDOJ/3712_autoAC.cpp b/HDOJ/3712_autoAC.cpp new file mode 100644 index 0000000..0b33800 --- /dev/null +++ b/HDOJ/3712_autoAC.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +using namespace std; +#define Y imag +#define X real +const double eps = 1e-9; +const char *err = "Error"; +const double pi = acos(-1.0); +typedef complex pnt; +static double dot(const pnt &a, const pnt& b) {return X(conj(a)*b);} +static double cross(const pnt &a, const pnt &b) {return imag(conj(a)*b);} +void work(const pnt& s, double argu) { + while(argu<0) argu+=2*pi; + while(argu >= 2*pi) argu -=2*pi; + if(argu < pi+eps) { + puts(err); + return ; + } + argu = - argu; + printf("%.3lf\n", X(s) +( abs(argu + 3*pi/2) -eps) return p0; + double s1 = cross(p2-p1,p0-p1), s2 = cross(p3-p1,p0-p1); + s1 = abs(s1), s2 = abs(s2); + double x = (X(p2) *s2 + X(p3)*s1) / (s1+ s2); + double y = (Y(p2) *s2 + Y(p3)*s1) / (s1+ s2); + pnt p(x,y); + if(cross(p3-p2,p1-p2)*cross(p3-p2,p0-p2)>0 && abs(p-p0) < abs(p-p1)) return p0; + return p; +} +double cal(double arg0, double arg1, double tmp) { + double t1 =arg1+pi/2-(arg0+pi); + double s1 = sin(t1); + double s2 = s1/tmp; + if(s2>=1.0 || s2 <=-1.0) return 1e10; + else return arg1-pi/2-asin(s2); +} +int main(){ + int tst; + double tmp; + cin >> tst; + pnt p[3]; + while(tst--) { + double x1,y1,x2,y2; + while(cin >> x1 >> y1 >> x2 >> y2){ + pnt p1(x1,y1), p2(x2,y2), p0; + int s = -1; + double mx = 1e10; + for(int i=0;i<3;i++){ + cin >> x1 >> y1; + p[i] = pnt(x1,y1); + } + cin >> tmp; + for(int i=0;i<3;i++) { + pnt P = jdg(p1,p2,p[i],p[(i+1)%3]); + if(P == p1) continue; + double v = abs(p1-P); + if(v < mx) mx = v, s = i, p0 = P; + } + if(s == -1){ + work(p1, arg(p2-p1)); + continue; + } + pnt p3; + double t = 0; + if(cross(p2-p1, p[(s+1)%3] - p[s])<0)t = pi; + double arg0 = cal(arg(p2-p1),arg(p[(s+1)%3] - p[s])+t,tmp); + pnt np = pnt(X(p0) + 200*cos(arg0), Y(p0) + 200*sin(arg0)); + int k = -1; + for(int i=0;i<3;i++) { + if(i==s) continue; + pnt P = jdg(p0,np,p[i],p[(i+1)%3]); + if(P == p0) continue; + k = i;p3 = P; + } + t = 0; + if(cross(p3-p0, p[(k+1)%3] - p[k])<0)t = pi; + double arg1 = cal(arg(p3 - p0), arg(p[(k+1)%3] - p[k])+t, 1.0/tmp); + if(arg1 == 1e10) { + puts(err); + continue; + } + work(p3,arg1); + } + } +} diff --git a/HDOJ/3713_autoAC.cpp b/HDOJ/3713_autoAC.cpp new file mode 100644 index 0000000..5984cf2 --- /dev/null +++ b/HDOJ/3713_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +using namespace std; +typedef pair, pair > Node; +const int MAXN = 8; +int T, mat[2][MAXN][MAXN]; +char stepto[MAXN][MAXN][MAXN][MAXN], mo[] = {'D','L','R','U'}; +Node s, t, fa[MAXN][MAXN][MAXN][MAXN]; +queue Q; +void ReadMat() +{ + for (int i = 1; i <= 6; i++) + for (int j = 1; j <= 6; j++) + { + scanf("%d", &mat[1][i][j]); + if (mat[1][i][j]&(1<<5)) + s.second = make_pair(i, j); + if (mat[1][i][j]&(1<<6)) + t.second = make_pair(i, j); + } +} +void PrintAns(Node v) +{ + if (stepto[v.first.first][v.first.second][v.second.first][v.second.second] == 'X') + return; + PrintAns(fa[v.first.first][v.first.second][v.second.first][v.second.second]); + printf("%c", stepto[v.first.first][v.first.second][v.second.first][v.second.second]); +} +int main() +{ + scanf("%d", &T); + ReadMat(); + while (--T) + { + memset(stepto, 0, sizeof(stepto)); + memcpy(mat[0], mat[1], MAXN*MAXN*sizeof(int)); + s.first = s.second; + t.first = t.second; + ReadMat(); + while (!Q.empty()) Q.pop(); + bool flag = 0; + Q.push(s); + stepto[s.first.first][s.first.second][s.second.first][s.second.second] = 'X'; + while (!Q.empty()) + { + Node u = Q.front(); Q.pop(); + if (u == t) + { + flag = 1; + break; + } + for (int i = 0; i < 4; i++) + { + Node v = u; + if (i == 0) + { + if (!(mat[0][u.first.first][u.first.second]&(1<<1))) + v.first.first++; + if (!(mat[1][u.second.first][u.second.second]&(1<<1))) + v.second.first++; + } + else if (i == 1) + { + if (!(mat[0][u.first.first][u.first.second]&(1<<0))) + v.first.second--; + if (!(mat[1][u.second.first][u.second.second]&(1<<0))) + v.second.second--; + } + else if (i == 2) + { + if (!(mat[0][u.first.first][u.first.second]&(1<<2))) + v.first.second++; + if (!(mat[1][u.second.first][u.second.second]&(1<<2))) + v.second.second++; + } + else + { + if (!(mat[0][u.first.first][u.first.second]&(1<<3))) + v.first.first--; + if (!(mat[1][u.second.first][u.second.second]&(1<<3))) + v.second.first--; + } + if (v.first.first < 1 || v.first.first > 6) + continue; + if (v.first.second < 1 || v.first.second > 6) + continue; + if (v.second.first < 1 || v.second.first > 6) + continue; + if (v.second.second < 1 || v.second.second > 6) + continue; + if (!(mat[0][v.first.first][v.first.second]&(1<<4)) || !(mat[1][v.second.first][v.second.second]&(1<<4))) + continue; + if (!stepto[v.first.first][v.first.second][v.second.first][v.second.second]) + { + Q.push(v); + stepto[v.first.first][v.first.second][v.second.first][v.second.second] = mo[i]; + fa[v.first.first][v.first.second][v.second.first][v.second.second] = u; + } + } + } + if (flag) + PrintAns(t); + else + printf("-1"); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/3714_autoAC.cpp b/HDOJ/3714_autoAC.cpp new file mode 100644 index 0000000..9350c4b --- /dev/null +++ b/HDOJ/3714_autoAC.cpp @@ -0,0 +1,50 @@ +#include"stdio.h" +#include"string.h" +#include"stdlib.h" +#include"math.h" +#define e 1e-9 +int n; +int a[10011],b[10011],c[10011]; +double MAX(double q,double p) +{ + return q>p?q:p; +} +double cal(double x) +{ + int i; + double max=-111111111; + for(i=0;ie) + { + mid=(left+right)/2; + midmid=(mid+right)/2; + mid_cal=cal(mid); + midmid_cal=cal(midmid); + if(mid_cal>midmid_cal) left=mid; + else right=midmid; + } + return cal(right); +} +int main() +{ + int T; + int i; + double ans; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + for(i=0;i +#include +#include +#include +#include +#include +#include +using namespace std; +#define print(x) cout<>x +#define N 512 +#define M 40000 +#define SIZE 10240 +struct node +{ + int val,next; + node(){} + node(int ival,int inext) + { + val=ival;next=inext; + } +}; +int n,m; +int a[SIZE],b[SIZE],c[SIZE]; +int head[SIZE]; +node g[M]; +int ind; +char instack[SIZE]; +stack st; +int dfn[SIZE],scc[SIZE],num[SIZE],low[SIZE]; +int sccnr,nr; +void init() +{ + ind=0; + memset(head,-1,sizeof(head)); + memset(instack,0,sizeof(instack)); + memset(scc,0,sizeof(scc)); + memset(num,0,sizeof(num)); + memset(low,0,sizeof(low)); + memset(dfn,0,sizeof(dfn)); + st=stack(); + nr=1;sccnr=0; +} +void tarjan(int pos) +{ + low[pos]=dfn[pos]=nr++; + st.push(pos); + instack[pos]=1; + for(int i=head[pos];i!=-1;i=g[i].next) + { + int j=g[i].val; + if(!dfn[j]) + { + tarjan(j); + low[pos]=min(low[pos],low[j]); + } + else if(instack[j]) + { + low[pos]=min(low[pos],dfn[j]); + } + } + if(dfn[pos]==low[pos]) + { + sccnr++; + while(1) + { + int t=st.top(); + instack[t]=0; + st.pop(); + scc[t]=sccnr; + num[sccnr]++; + if(t==pos) break; + } + } +} +bool zSat() +{ + for(int i=0;i>1; + makeG(mid); + if(zSat()) l=mid+1; + else r=mid-1; + } + return r; +} +int main() +{ + int T; + input(T); + while(T--) + { + input(n>>m); + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxa = 20; +const int maxc = 40; +const int maxn = 60; +double dp[2][maxn][3][maxa][maxc]; +double b[2][3], d[2][3]; +inline double P(int i, int j, int n) +{ + return max(0.0, min(1.0, b[i][j] - n * d[i][j])); +} +double f(int id, int n, int m, int a, int c) +{ + double &ret = dp[id][n][m][a][c]; + if (ret >= 0) return ret; + if (a == 0 && c == 0) return ret = 0; + int n0 = n, a0 = a; + if (m == 0) n++; + if (m == 2) a++; + m = (m + 1) % 3; + ret = 0; + if (a0 > 0) + { + ret = max(ret, P(id, 0, n0) * (1.0 - f(1-id, n, m, a-1, c))); + ret = max(ret, P(id, 1, n0) * (1.0 - f(1-id, n, m, a-1, c+1))); + } + if (c > 0) + { + ret = max(ret, P(id, 2, n0) * (1.0 - f(1-id, n, m, a, c-1))); + } + return ret; +} +int main() +{ + int T, n; + scanf("%d", &T); + while (T--) + { + for (int i=0;i<2;i++) + for (int n=0;n +#define maxn 50005 +#define ll long long +using namespace std; +ll cnt[maxn]; +ll num[maxn]; +int n,k,t; +bool check(ll x) +{ + ll sum_2=0,sum_1=0,sum=0,ans=0; + int j=n-1; + for(int i=n-1;i>=0;i--) + { + if(j>i) + { + while((j-i)*(j-i)>=x) + { + sum_2-=cnt[j]*(j-i-1)*(j-i-1); + sum_1-=cnt[j]*(j-i-1); + sum-=cnt[j]; + j--; + } + } + sum_2+=2*sum_1+sum; + sum_1+=sum; + ll y=num[i]-sum*x+sum_2; + if(y<0)cnt[i]=0; + else cnt[i]=y/x+1; + sum+=cnt[i]; + ans+=cnt[i]; + } + return ans<=k; +} +int main() +{ + cin>>t; + while(t--) + { + cin>>n>>k; + for(int i=0;i>num[i]; + ll l=1,r=1e12; + while(l>1; + if(check(mid))r=mid; + else l=mid+1; + } + cout< +#include +#include +#include +#define size 10001 +#define _clr(x) memset(x,0xff,sizeof(int)*26) +#define inf 1000000000 +using namespace std; +int g[26][26]; +bool l[26][size]; +int KM(int n); +bool HaveLetter[26]; +struct loc +{ + int a[size]; + int len; + loc(){len = 0;} + void add(int val) + { + a[len++] = val; + } +}locate1[26],locate2[26],rem2,rem1; +void InitGraph(int n) +{ + int i,j,A; + memset(HaveLetter,0,sizeof(HaveLetter)); + for(i=0;i<26;i++) + locate2[i].len = 0; + for (i=0;il1[i]?g[i][j]:l1[i]; + for (i=0;i=0;j=p) + match2[j]=k=t[j],p=match1[k],match1[k]=j; + } + if (match1[i]<0) + { + for (i--,p=inf,k=0;k<=q;k++) + for (j=0;j +#include +struct Snooker{ + char name[2][30]; + int score[2]; + int ball_cnt[10]; + int red_cnt; + int turn; + int next; + bool over; + bool foul[5]; + int penalty; + int ball_first; + bool replaced[10]; + bool first; + bool second; + bool last; + char stroke[2000]; + char ball_name[10]; +}game; +void init1() +{ + int i; + game.score[0] = game.score[1] = 0; + game.ball_cnt[1] = 15; + for(i=2;i<=7;i++) + game.ball_cnt[i] = 1; + game.turn = 0; + game.next = 1; + game.last = false; + game.over = false; +} +void init2() +{ + game.red_cnt = 0; + memset(game.foul,false,sizeof(game.foul)); + game.penalty = 4; + game.ball_first = -1; + memset(game.replaced,false,sizeof(game.replaced)); + game.first = game.second = false; +} +int gao1() +{ + char ch[][10] = {"None","Red","Yellow","Green","Brown","Blue","Pink","Black","White"}; + for(int i=0;i<9;i++) + if(strcmp(game.ball_name,ch[i])==0) + return i; + return -1; +} +void gao2() +{ + int state = gao1(); + if(state==0) + game.foul[0] = true; + else + { + if(game.next == 1 && state > 1) + game.foul[1] = true; + else if(game.next > 1 && state == 1) + game.foul[1] = true; + else if(game.next <= 7 && game.next != state) + game.foul[1] = true; + } + game.first = true; + game.ball_first = state; +} +void gao3() +{ + if(game.second) + { + int state = gao1(); + if(game.ball_first != state) + game.foul[2] = true; + if(state > 7) + game.foul[3] = true; + if(state == 1) + game.red_cnt++; + game.replaced[state] = true; + } +} +void gao4() +{ + int i; + if(game.last) + { + if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3]) + { + printf("Foul!\n"); + game.score[game.turn^1] += 7; + } + else if(game.second) + game.score[game.turn] += 7; + game.turn^=1; + printf("%d : %d\n",game.score[0],game.score[1]); + if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3] || game.second) + { + if(game.score[0] == game.score[1]) + { + printf("Tie\nRespot Black\n"); + game.next = 7; + } + else + { + if(game.score[0] > game.score[1]) + printf("%s wins\n",game.name[0]); + else + printf("%s wins\n",game.name[1]); + game.over = true; + } + } + else + printf("%s's turn\n",game.name[game.turn]); + return; + } + game.ball_cnt[1] -= game.red_cnt; + if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3]) + { + printf("Foul!\n"); + game.turn^=1; + game.score[game.turn] += game.penalty; + printf("%d : %d\n",game.score[0],game.score[1]); + if(game.replaced[2] || game.replaced[3] || game.replaced[4] || game.replaced[5] || game.replaced[6] || game.replaced[7]) + { + char ch[][10] = {"","","Yellow","Green","Brown","Blue","Pink","Black"}; + printf("Respot"); + for(i=2;i<=7;i++) + { + if(game.replaced[i]) + printf(" %s",ch[i]); + } + printf("\n"); + } + for(i=1;i<=7;i++) + { + if(game.ball_cnt[i] > 0) + { + game.next = i; + break; + } + } + if(!game.foul[3]) + printf("%s's turn\n",game.name[game.turn]); + else + printf("%s's turn, in-hand\n",game.name[game.turn]); + } + else + { + if(game.next == 1) + game.score[game.turn] += game.red_cnt; + else if(game.second) + game.score[game.turn] += game.ball_first; + printf("%d : %d\n",game.score[0],game.score[1]); + if(game.next == 8 && game.second) + { + char ch[][10] = {"","","Yellow","Green","Brown","Blue","Pink","Black"}; + printf("Respot"); + for(i=2;i<=7;i++) + { + if(game.replaced[i]) + printf(" %s",ch[i]); + } + printf("\n"); + } + else + { + if(game.next > 1 && game.second) + { + game.ball_cnt[game.next]--; + if(game.ball_cnt[6] == 0) + game.last = true; + } + } + if(game.red_cnt > 0) + game.next = 8; + else + { + for(i=1;i<=7;i++) + { + if(game.ball_cnt[i] > 0) + { + game.next = i; + break; + } + } + } + if(!game.second) + { + game.turn^=1; + printf("%s's turn\n",game.name[game.turn]); + } + } +} +int Max(int a,int b) +{ + if(a > b) + return a; + return b; +} +int main() +{ + int t,ca,len,i,fi; + scanf("%d",&t); + for(ca=1;ca<=t;ca++) + { + if(ca>1) + printf("\n"); + printf("Frame %d\n",ca); + init1(); + scanf(" %s %s",game.name[0],game.name[1]); + getchar(); + printf("%s's turn, in-hand\n",game.name[game.turn]); + while(!game.over) + { + gets(game.stroke); + if(strcmp(game.stroke,"Play again")==0) + { + game.turn^=1; + if(!game.foul[3]) + printf("%s's turn\n",game.name[game.turn]); + else + printf("%s's turn, in-hand\n",game.name[game.turn]); + continue; + } + if(strcmp(game.stroke,game.name[0])==0) + { + game.turn=0; + printf("%s's turn, in-hand\n",game.name[game.turn]); + continue; + } + if(strcmp(game.stroke,game.name[1])==0) + { + game.turn=1; + printf("%s's turn, in-hand\n",game.name[game.turn]); + continue; + } + len = strlen(game.stroke); + init2(); + for(i=fi=0;i +#include +#include +#include +using namespace std; +#define inf 100000000 +char s[35],ps[35]; +map mp; +const int limit[5]={0,1,4,4,2}; +int v[25],g[25][25],id[25],cnt[5],t[12],ans; +int gao(char x[]) +{ + if (x[0]=='g') return 1; + if (x[0]=='d') return 2; + if (x[0]=='m') return 3; + return 4; +} +void init() +{ + int m,x; + mp.clear(); + memset(g,0,sizeof(g)); + for (int i=1;i<=23;++i) + { + mp[s]=i; + id[i]=gao(ps); + if (i<23) scanf("%s%d%s",s,&v[i+1],ps); + } + scanf("%d",&m); + for (int i=1;i<=m;++i) + { + scanf("%s%s%d",s,ps,&x); + g[mp[s]][mp[ps]]=x; + g[mp[ps]][mp[s]]=x; + } +} +void updata() +{ + int temp=0; + for (int i=1;i<=11;++i) + temp+=v[t[i]]; + for (int i=1;i<=11;++i) + for (int j=i+1;j<=11;++j) + temp+=g[t[i]][t[j]]; + if (temp>ans) ans=temp; +} +void dfs(int x,int y) +{ + if (y==11) + { + updata(); + return; + } + if (x>23) return; + for (int i=0;i<=1;++i) + { + cnt[id[x]]+=i; + if (cnt[id[x]]<=limit[id[x]]) + { if (i) t[y+1]=x; + dfs(x+1,y+i); + } + cnt[id[x]]-=i; + } +} +void solve() +{ + memset(cnt,0,sizeof(cnt)); + ans=-inf; + dfs(1,0); + if (ans==-inf) printf("impossible\n"); + else printf("%d\n",ans); +} +int main() +{ + while (scanf("%s%d%s",s,&v[1],ps)!=EOF) + { + init(); + solve(); + } + return 0; +} diff --git a/HDOJ/3721_autoAC.cpp b/HDOJ/3721_autoAC.cpp new file mode 100644 index 0000000..97ad566 --- /dev/null +++ b/HDOJ/3721_autoAC.cpp @@ -0,0 +1,100 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 2505; +struct Graph { + int hed[maxn], pnt[maxn*2], val[maxn*2], nxt[maxn*2], cnt; + void init(int n) { + cnt = 0; + memset(hed, -1, 4 * n); + } + void addedge(int x, int y, int v) { + pnt[cnt] = y; val[cnt] = v; nxt[cnt] = hed[x]; hed[x] = cnt++; + pnt[cnt] = x; val[cnt] = v; nxt[cnt] = hed[y]; hed[y] = cnt++; + } +} g; +queue Q; +int n; +int banx, bany; +int par[maxn], dis[maxn]; +int xx, yy; +int bfs(int x) { + int ret = x; + dis[x] = 0; + Q.push(x); + while (!Q.empty()) { + int a = Q.front(); + Q.pop(); + for (int p = g.hed[a]; p != -1; p = g.nxt[p]) { + int b = g.pnt[p]; + if (dis[b] != -1) continue; + if (a == banx && b == bany || a == bany && b == banx) continue; + par[b] = a; + dis[b] = dis[a] + g.val[p]; + Q.push(b); + if (dis[b] > dis[ret]) ret = b; + } + } + return ret; +} +void FindRoad(int x) { + memset(par, -1, 4 * n); + memset(dis, -1, 4 * n); + yy = bfs(x); + memset(par, -1, 4 * n); + memset(dis, -1, 4 * n); + xx = bfs(yy); +} +int ans; +vector v, d; +void Solve() { + int t, disx, disy, disedge, dxx, dyy; + banx = bany = -1; + FindRoad(0); + v.clear(); d.clear(); + t = xx; + while (true) { + v.push_back(t); + t = par[t]; + if (t == -1) break; + d.push_back(dis[v.back()] - dis[t]); + } + ans = dis[xx]; + for (int i = 1; i < v.size(); i++) { + banx = v[i-1]; bany = v[i]; + disedge = d[i-1]; + FindRoad(banx); + dxx = disx = dis[xx]; + for (t = xx; t != -1; t = par[t]) + disx = min(disx, max(dis[xx] - dis[t], dis[t])); + FindRoad(bany); + dyy = disy = dis[xx]; + for (t = xx; t != -1; t = par[t]) + disy = min(disy, max(dis[xx] - dis[t], dis[t])); + ans = min(ans, max(max(disx + disy + disedge, dxx), dyy)); + } +} +int main() { + int t, x, y, v, i, cas = 1; + for (scanf("%d", &t); t--; ) { + scanf("%d", &n); + g.init(n); + for (i = 1; i < n; i++) { + scanf("%d %d %d", &x, &y, &v); + g.addedge(x, y, v); + } + Solve(); + printf("Case %d: %d\n", cas++, ans); + } + return 0; +} diff --git a/HDOJ/3722_autoAC.cpp b/HDOJ/3722_autoAC.cpp new file mode 100644 index 0000000..71b585b --- /dev/null +++ b/HDOJ/3722_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +using namespace std; +#define MAX 201 +#define MAXN 0xffffff +int map[MAX][MAX],link[MAX],dx[MAX],dy[MAX]; +bool visx[MAX],visy[MAX]; +int n,lack; +char A[201][10001]; +bool DFS(int v) +{ + visx[v]=true; + for(int i=1;i<=n;i++) + { + if(visy[i]) + continue; + int t=dx[v]+dy[i]-map[v][i]; + if(!t) + { + visy[i]=true; + if(link[i]==-1||DFS(link[i])) + { + link[i]=v; + return true; + } + } + else + { + if(tdx[i]) + dx[i]=map[i][j]; + } + for(i=1;i<=n;i++) + { + while(true) + { + memset(visx,0,sizeof(visx)); + memset(visy,0,sizeof(visy)); + lack=MAXN; + if(DFS(i)) + break; + for(j=1;j<=n;j++) + { + if(visx[j]) + dx[j]-=lack; + if(visy[j]) + dy[j]+=lack; + } + } + } + int ans=0; + for(i=1;i<=n;i++) + ans+=map[link[i]][i]; + cout<=0&&A[i][q]==A[j][p]) + { + q++;p--; + } + map[i][j]=q; + } + } + } +} +int main() +{ + while(cin>>n) + { + int i,j; + for(i=1;i<=n;i++) + { + for(j=1;j<=n;j++) + map[i][j]=0; + } + for(i=1;i<=n;i++) + scanf("%s",A[i]); + Q(); + KM(); + } + return 0; +} diff --git a/HDOJ/3724_autoAC.cpp b/HDOJ/3724_autoAC.cpp new file mode 100644 index 0000000..55bac5b --- /dev/null +++ b/HDOJ/3724_autoAC.cpp @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include +using namespace std; +struct dictree{ + int num; + dictree *child[30]; +}; +dictree *root; +int ans; +struct node +{ + double val; + int iid; +}p[8]; +void insert(char *s){ + int len,i,j; + dictree *current,*newnode; + len=strlen(s); + current=root; + for(i=0;ichild[s[i]-'a']!=0){ + current=current->child[s[i]-'a']; + current->num++; + } + else{ + newnode=(struct dictree *)malloc(sizeof(struct dictree)); + for(j=0;j<=26;j++){ + newnode->child[j]=NULL; + } + newnode->num=1; + current->child[s[i]-'a']=newnode; + current=current->child[s[i]-'a']; + } + } + return; +} +void search(char *s){ + dictree *current; + int i,j,len; + current=root; + len=strlen(s); + for(i=0;ichild[s[i]-'a']!=0){ + current=current->child[s[i]-'a']; + } + else{ + return; + } + } + ans+=current->num; +} +int cmp(node a,node b) +{ + if(a.val==b.val)return a.iidchild[i]=0; + root->num=0; + for(i=1;i<=n;i++){ + scanf("%s",s); + insert(s); + } + ans=0; + int k,t; + for(i=1;i<=m;i++) + { + scanf("%d",&k); + for(j=0;jp[qq].val){ + tem=p[pp]; + p[pp]=p[qq]; + p[qq]=tem; + } + int tto=1; + while(p[tto].val/p[tto-1].val<=key)tto++; + asc=0; + for(t=tto;t<8;t++){ + asc+=pow(p[t].iid); + } + s1[j]=asc; + } + s1[k]='\0'; + search(s1); + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3725_autoAC.cpp b/HDOJ/3725_autoAC.cpp new file mode 100644 index 0000000..b870e06 --- /dev/null +++ b/HDOJ/3725_autoAC.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int N=30000+10; +typedef long long LL; +struct Point{ + LL x,y; + Point (LL a=0,LL b=0):x(a),y(b){} + Point operator - (const Point &p)const{ + return Point(x - p.x, y - p.y); + } +}; +LL sum[N],Ti[N],ti; +int n,M,r,anger[N]; +typedef Point Vector; +LL Cross(const Vector &u,const Vector &v){ + return u.x*v.y - u.y*v.x; +} +struct dequeue{ + Point q[N]; + int head,tail; + void init(){ + head = 1; tail = 0; + } + void push(const Point &u){ + while (head < tail && Cross(q[tail] - q[tail-1],u - q[tail-1]) <= 0) + tail--; + q[++tail] = u; + } + void pop(int k,int i,int w){ + while (head <= tail && anger[i] - anger[q[head].x] > w) head++; + while (head < tail && -k*q[head].x + q[head].y >= -k*q[head+1].x + q[head+1].y) head++; + } +}H; +struct vegetable{ + int vi,ai; + LL di; + vegetable(int v=0,int a=0,LL d=0):vi(v),ai(a),di(d){} + bool operator < (const vegetable &p)const{ + return vi>p.vi; + } + void input(){ + scanf("%d%d%I64d",&vi,&ai,&di); + } + void output(){ + cout<< vi <<" "<< ai <<" "<< di << endl; + } +}vg[N]; +void init(){ + sort(vg+1,vg+n+1); + anger[0] = sum[0] = Ti[0] = 0; + for (int i=1;i<=n;i++) { + sum[i]=sum[i-1]+vg[i].di; + Ti[i]=Ti[i-1]+i*vg[i].di; + anger[i] = anger[i-1] + vg[i].ai; + } +} +LL dp[11][N]; +int check(int m){ + for (int i=0;i<=n;i++){ + if (anger[i] <= m) dp[0][i]=Ti[i]; + else dp[0][i] = Ti[i]+ti ; + } + for (int j=1;j<=M;j++){ + H.init(); + H.push(Point(0,(j-1)*r)); + for (int i=1;i<=n;i++){ + H.pop(sum[i],i,m); + if (H.head<=H.tail) + dp[j][i] = -sum[i]*H.q[H.head].x + H.q[H.head].y + Ti[i] + r; + else dp[j][i] = ti + 100; + if (dp[j-1][i] < ti) H.push(Point(i,sum[i]*i + dp[j-1][i] - Ti[i])); + } + } + LL ret = dp[0][n]; + for (int i=1; i<=M;i++){ + if(dp[i][n] < ret) ret = dp[i][n]; + } + if (ret > ti) return 0; + return 1; +} +void solve(int l,int r){ + init(); + int ret=-1; + while (r>=l){ + int m=(l+r)>>1; + if (check(m)){ + ret=m; r=m-1; + }else l=m+1; + } + if (ret == -1) printf("I have no idea\n"); + else printf("%d\n",ret); +} +int main(){ + int T; scanf("%d",&T); + while (T--){ + scanf("%d%d%d%I64d",&n,&M,&r,&ti); + int allai = 0; + for (int i=1;i<=n;i++){ + vg[i].input(); + allai += vg[i].ai; + } + solve(1,allai); + } + return 0; +} diff --git a/HDOJ/3726_autoAC.cpp b/HDOJ/3726_autoAC.cpp new file mode 100644 index 0000000..d8aee2c --- /dev/null +++ b/HDOJ/3726_autoAC.cpp @@ -0,0 +1,240 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define Key_value ch[ch[root][1]][0] +const int MAXN = 20010; +int pre[MAXN],ch[MAXN][2],key[MAXN],size[MAXN]; +int root; +void NewNode(int &r,int father,int loc,int k) +{ + r = loc; + pre[r] = father; + ch[r][0] = ch[r][1] = 0; + key[r] = k; + size[r] = 1; +} +void push_up(int r) +{ + size[r] = size[ch[r][0]] + size[ch[r][1]] + 1; +} +void Init() +{ + root = 0; + ch[root][0] = ch[root][1] = key[root] = size[root] = 0; + pre[root] = 0; +} +void Rotate(int x,int kind) +{ + int y = pre[x]; + ch[y][!kind] = ch[x][kind]; + pre[ch[x][kind]] = y; + if(pre[y]) + ch[pre[y]][ch[pre[y]][1]==y] = x; + pre[x] = pre[y]; + ch[x][kind] = y; + pre[y] = x; + push_up(y); +} +void Splay(int r,int goal) +{ + while(pre[r] != goal) + { + if(pre[pre[r]] == goal) + Rotate(r,ch[pre[r]][0] == r); + else + { + int y = pre[r]; + int kind = ch[pre[y]][0]==y; + if(ch[y][kind] == r) + { + Rotate(r,!kind); + Rotate(r,kind); + } + else + { + Rotate(y,kind); + Rotate(r,kind); + } + } + } + push_up(r); + if(goal == 0) root = r; +} +int Get_kth(int r,int k) +{ + int t = size[ch[r][0]] + 1; + if(t == k)return r; + if(t > k)return Get_kth(ch[r][0],k); + else return Get_kth(ch[r][1],k-t); +} +void Insert(int loc,int k) +{ + int r = root; + if(r == 0) + { + NewNode(root,0,loc,k); + return; + } + while(ch[r][key[r] size[t2]) + swap(t1,t2); + root = t2; + erase(t1); +} +int main() +{ + int N,M; + int iCase = 0; + while(scanf("%d%d",&N,&M) == 2 ) + { + if(N == 0 && M == 0) break; + iCase++; + memset(head,-1,sizeof(head)); + tot = 0; + int v; + for(int i = 1;i <= N;i++) + { + scanf("%d",&v); + add_value(i,v); + } + for(int i = 1;i <= M;i++) + { + scanf("%d%d",&edge[i].u,&edge[i].v); + } + q_num = 0; + memset(used,false,sizeof(used)); + while(scanf("%s",&query[q_num].op) == 1) + { + if(query[q_num].op[0] == 'E')break; + if(query[q_num].op[0] == 'D') + { + scanf("%d",&query[q_num].x); + used[query[q_num].x] = true; + } + else if(query[q_num].op[0] == 'Q') + scanf("%d%d",&query[q_num].x,&query[q_num].y); + else if(query[q_num].op[0] == 'C') + { + scanf("%d%d",&query[q_num].x,&query[q_num].y); + add_value(query[q_num].x,query[q_num].y); + } + q_num++; + } + memset(F,-1,sizeof(F)); + for(int i = 1;i <= N;i++) + NewNode(root,0,i,to[head[i]]); + for(int i = 1;i <= M;i++) + if(!used[i]) + bing(edge[i].u,edge[i].v); + double ans = 0; + int cnt = 0; + for(int i = q_num-1; i>= 0 ;i--) + { + if(query[i].op[0] == 'Q') + { + Splay(query[i].x,0); + if(size[root] < query[i].y || query[i].y <= 0) + { + cnt++; + continue; + } + ans += key[Get_kth(root,size[root] - query[i].y + 1)]; + cnt++; + } + else if(query[i].op[0] == 'D') + { + int tmp = query[i].x; + bing(edge[tmp].u,edge[tmp].v); + } + else if(query[i].op[0] == 'C') + { + Splay(query[i].x,0); + Delete(); + head[query[i].x] = ne[head[query[i].x]]; + Insert(query[i].x,to[head[query[i].x]]); + } + } + if(cnt == 0)cnt = 1; + printf("Case %d: %.6lf\n",iCase,ans/cnt); + } + return 0; +} diff --git a/HDOJ/3727_autoAC.cpp b/HDOJ/3727_autoAC.cpp new file mode 100644 index 0000000..6f942cb --- /dev/null +++ b/HDOJ/3727_autoAC.cpp @@ -0,0 +1,124 @@ +# include +# include +# include +using namespace std; +# define N 100005 +int arr[20][N]; +struct node +{ + int s,e,layer; + int c; +}st[4*N]; +int q[500000][4],c; +int remap[N],position[N]; +map refer; +void init(int s,int e,int layer,int pos=1) +{ + st[pos].s=s;st[pos].e=e; + st[pos].layer=layer; + st[pos].c=st[pos].s; + if(s!=e) init(s,(s+e)/2,layer+1,pos<<1),init((s+e)/2+1,e,layer+1,(pos<<1)+1); +} +void insert(int value,int pos=1) +{ + if(st[pos].s==st[pos].e) + arr[st[pos].layer][st[pos].c++]=value; + else + { + if(value<=(st[pos].s+st[pos].e)/2) + { + arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+1; + st[pos].c++; + insert(value,pos<<1); + } + else + { + arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1]); + st[pos].c++; + insert(value,(pos<<1)+1); + } + } +} +int q1(int s,int t,int k,int pos=1) +{ + if(st[pos].s==st[pos].e) + return remap[arr[st[pos].layer][st[pos].s]]; + else + { + if(arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1])>=k)//left + return q1(st[pos].s+(s==st[pos].s?0:arr[st[pos].layer][s-1]),st[pos].s+arr[st[pos].layer][t]-1,k,pos<<1); + else//right + { + k-=arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1]); + return q1((st[pos].s+st[pos].e)/2+1+s-1-st[pos].s+1-(s==st[pos].s?0:arr[st[pos].layer][s-1]),(st[pos].s+st[pos].e)/2+1+t-st[pos].s+1-arr[st[pos].layer][t]-1,k,(pos<<1)+1); + } + } +} +int q2(int s,int pos=1) +{ + if(st[pos].s==st[pos].e) return 1; + else if(arr[st[pos].layer][s]-(s==st[pos].s?0:arr[st[pos].layer][s-1])) + return q2(st[pos].s+arr[st[pos].layer][s]-1,pos<<1); + else + return (st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+q2((st[pos].s+st[pos].e)/2+1+s-st[pos].s+1-arr[st[pos].layer][s]-1,(pos<<1)+1); +} +int q3(int k,int pos=1) +{ + if(st[pos].s==st[pos].e) return remap[arr[st[pos].layer][st[pos].s]]; + else if(k<=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])) return q3(k,pos<<1); + else return q3(k-(st[pos].s==st[pos].c?0:arr[st[pos].layer][st[pos].c-1]),(pos<<1)+1); +} +int main() +{ + int n,test=1; + while(scanf("%d",&n)!=EOF) + { + refer.clear();c=1; + memset(arr,0,sizeof(arr)); + for(int i=0;i::iterator i=refer.begin();i!=refer.end();i++) + remap[c]=i->first,i->second=c++; + init(1,c-1,0); + long long t[4]={0,0,0,0}; + int now=1; + for(int i=0;i +#include +#define N 100005 +int mark[N],link[N]; +struct node +{ + int x,y; +}a[105]; +int ss[105]; +int n; +int dfs(int t) +{ + int i; + for(i=a[t].x;i<=a[t].y;i++) + { + if(mark[i]==-1) + { + mark[i]=1; + if(link[i]==-1||dfs(link[i])) + { + link[i]=t; + ss[t]=1; + return 1; + } + } + } + return 0; +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + int i; + for(i=1;i<=n;i++) + scanf("%d%d",&a[i].x,&a[i].y); + memset(link,-1,sizeof(link)); + memset(ss,0,sizeof(ss)); + int sum; + sum=0; + for(i=n;i>=1;i--) + { + memset(mark,-1,sizeof(mark)); + if(dfs(i)) + sum++; + } + printf("%d\n",sum); + for(i=1;i<=n-1;i++) + { + if(ss[i]==1) + printf("%d ",i); + } + printf("%d\n",i); + } + return 0; +} diff --git a/HDOJ/3730_autoAC.cpp b/HDOJ/3730_autoAC.cpp new file mode 100644 index 0000000..fa053f3 --- /dev/null +++ b/HDOJ/3730_autoAC.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include +#include +using namespace std; +#define maxn 1000001 +#define ll __int64 +struct Node +{ + ll a,b; +}; +Node no[maxn]; +bool cmp(Node x,Node y) +{ + return x.a=no[i].a)ans+=no[i].a; + else ans+=(ans+1)*no[i].b; + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/3732_autoAC.cpp b/HDOJ/3732_autoAC.cpp new file mode 100644 index 0000000..eaeb8e9 --- /dev/null +++ b/HDOJ/3732_autoAC.cpp @@ -0,0 +1,45 @@ +#include +#include +using namespace std; +const int maxc = 10005; +int dp[maxc], re[11][11], cost; +void Pack(int v, int c, int k) +{ + for (int m = 1; k > 0; m += m) + { + if (m > k) + m = k; + k -= m; + int vv = v * m, cc = c * m; + for (int j = cost; j - cc >= 0; j--) + { + if (dp[j] < dp[j-cc] + vv) + dp[j] = dp[j-cc] + vv; + } + } +} +int main() +{ + int n, i, j; + int v, c; + while (scanf("%d %d", &n, &cost) != EOF) + { + memset(dp, 0, (cost + 1) * 4); + memset(re, 0, sizeof(re)); + for (i = 0; i < n; i++) + { + scanf("%*c%*s %d %d", &v, &c); + re[v][c]++; + } + for (i = 1; i <= 10; i++) + for (j = 0; j <= 10; j++) + { + if (re[i][j] > 0) + { + Pack(i, j, re[i][j]); + } + } + printf("%d\n", dp[cost]); + } + return 0; +} diff --git a/HDOJ/3734_autoAC.cpp b/HDOJ/3734_autoAC.cpp new file mode 100644 index 0000000..615fd47 --- /dev/null +++ b/HDOJ/3734_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +using namespace std; +const int Mn = 100010; +const int Mod = 1e9 + 7; +int a[Mn], b[Mn], n; +int s[4][Mn]; +pairc[Mn]; +inline int query(int k, int num){ + int res(0); + for(;k;k -= k &-k) + res = (res+s[num][k]) %Mod; + return res; +} +inline void update(int k, int val, int num){ + for(; k <= n; k += k & -k){ + s[num][k] = (s[num][k] + val) % Mod; + } +} +int main() +{ + int T; + scanf("%d", &T); + while(T--){ + memset(s, 0, sizeof(s)); + scanf("%d", &n); + for(int i = 1; i <= n; ++i) + scanf("%d", &a[i]),b[i] = a[i]; + sort(b+1, b+n+1); + for(int i = 1; i <= n; ++i){ + a[i] = lower_bound(b+1, b+n+1,a[i]) - b; + c[i] = make_pair(a[i],i); + } + sort(c+1, c+n+1); + long long ans(0); + for(int i= 1; i <= n; ++i){ + long long t0 = query(c[i].second, 0); + long long t1 = query(c[i].second, 1); + long long t2 = query(n-c[i].second+1,2); + long long t3 = query(n-c[i].second+1,3); + ans = (ans+(t0-(1+t1) * t1 /2) % Mod *(t2-(1+t3)*t3/2)%Mod) %Mod; + update(c[i].second, c[i].second, 0); + update(c[i].second, 1, 1); + update(n-c[i].second+1, n-c[i].second+1,2); + update(n-c[i].second+1,1,3); + } + printf("%d\n", (int)(ans%Mod+Mod) %Mod); + } + return 0; +} diff --git a/HDOJ/3735_autoAC.cpp b/HDOJ/3735_autoAC.cpp new file mode 100644 index 0000000..eba5385 --- /dev/null +++ b/HDOJ/3735_autoAC.cpp @@ -0,0 +1,93 @@ +#include +#include +#include +#include +#include +#define MOD 1000000003 +#define MAXN 2010 +using namespace std; +using namespace std; +long long n, m, b[MAXN], e[MAXN] = {0}, zero[MAXN] = {0}; +struct poly { + long long a[MAXN]; + poly(long long ta[]) { + for (int i = 0; i < 2 * m; i++) a[i] = ta[i]; + } + poly operator*(const poly & po) { + poly re(zero); + for (int i = 0; i < m; i++) { + if (po.a[i]) + for (int j = 0; j < m; j++) { + re.a[i + j] += a[j] * po.a[i]; + re.a[i + j] %= MOD; + } + } + for (int i = 2 * m - 1; i >= m; i--) { + if (re.a[i]) + for (int j = 0; j < m; j++) { + re.a[i + j - m] += b[j] * re.a[i]; + re.a[i + j - m] %= MOD; + } + a[i] = 0; + } + return re; + } + void left() { + for (int i = m - 1; i >= 0; i--) a[i + 1] = a[i]; + a[0] = 0; + for (int j = 0; j < m; j++) { + a[j] += b[j] * a[m]; + a[j] %= MOD; + } + a[m] = 0; + } + void square() { + long long ans[MAXN] = {0}; + for (int i = 0; i < m; i++) { + if (a[i]) + for (int j = 0; j < m; j++) { + ans[i + j] += a[j] * a[i]; + ans[i + j] %= MOD; + } + } + for (int i = 2 * m - 1; i >= m; i--) { + if (ans[i]) + for (int j = 0; j < m; j++) { + ans[i + j - m] += b[j] * ans[i]; + ans[i + j - m] %= MOD; + } + ans[i] = 0; + } + for (int i = 0; i < 2 * m; i++) a[i] = ans[i]; + } + poly operator^(long long power) { + poly re(e), tem(e); + if (power <= 0) return re; + tem.left(); + while (power) { + if (power & 1) re = re * tem; + power >>= 1; + tem.square(); + } + return re; + } +}; +long long ai[MAXN]; +int main() { + int cc; + cin >> cc; + e[0] = 1; + while (cc--) { + cin >> m >> n; + memset(ai, 0, sizeof (ai)); + memset(b, 0, sizeof (b)); + for (int i = 0; i < m; i++) scanf(" %I64d", ai + i); + for (int i = 0; i < m; i++) scanf(" %I64d", b + i); + poly tem(b), ta(ai); + tem = tem^n; + long long ans = 0; + for (int i = 0; i < m; i++) + ans = (ans + tem.a[i] * ta.a[i]) % MOD; + cout << ans << endl; + } +} diff --git a/HDOJ/3738_autoAC.cpp b/HDOJ/3738_autoAC.cpp new file mode 100644 index 0000000..74fd35f --- /dev/null +++ b/HDOJ/3738_autoAC.cpp @@ -0,0 +1,54 @@ +#include +#include +#include +#include +#define N 100010 +int n; +__int64 a[N], x, y, z; +int q[N], ed; +__int64 min(__int64 a,__int64 b ) +{ + return a a[i]) + res += (a[i - 1] - a[i]) * y; + else + res += (a[i] - a[i - 1]) * x; + } + } + ed = 0; + q[ed++] = 0; + for (int i = 1; i < n; ++i) { + if (a[q[ed - 1]] >= a[i]) q[ed++] = i; + else { + while (ed > 1 && a[q[ed - 1]] < a[i]) { + --ed; + __int64 tmp, t = min(a[i], a[q[ed - 1]]) - a[q[ed]]; + if ((tmp = (x + y - (i - q[ed - 1] - 1) * z) * t) > 0) { + res -= tmp; + } + } + if (a[q[ed - 1]] <= a[i]) --ed; + q[ed++] = i; + } + } + printf("%I64d\n", res); +} +int main() { + int cas; + scanf("%d", &cas); + while (cas--) { + scanf("%d", &n); + scanf("%I64d%I64d%I64d", &x, &y, &z); + for (int i = 0; i < n; ++i) { + scanf("%I64d", &a[i]); + } + solve(); + } + return 0; +} diff --git a/HDOJ/3739_autoAC.cpp b/HDOJ/3739_autoAC.cpp new file mode 100644 index 0000000..ca686a7 --- /dev/null +++ b/HDOJ/3739_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#define INF 0x7fffffff +#define MAXN 2010 +#define MAXM 600000 +int pt[MAXM], head[MAXN], next[MAXM], flow[MAXM], lvl[MAXN], queue[MAXN]; +int pos; +int arr[MAXN], stage[MAXN]; +int n; +void AddEdge(int a, int b, int c) +{ + pt[++pos] = b; + next[pos] = head[a]; + head[a] = pos; + flow[pos] = c; +} +void Connect(int a, int b, int c) +{ + AddEdge(a, b, c); + AddEdge(b, a, 0); +} +bool bfs(int s, int t) +{ + int qs, qe, v, e; + memset (lvl, 0, sizeof lvl); + lvl[s] = 1; + qs = qe = 0; + queue[qe++] = s; + while (qs < qe) + { + v = queue[qs++]; + for (e = head[v]; e != -1; e = next[e]) + if (flow[e] > 0 && lvl[pt[e]] == 0) + { + lvl[pt[e]] = lvl[v] + 1; + queue[qe++] = pt[e]; + } + } + return lvl[t] > 0; +} +int Update(int v, int t, int tmpflow) +{ + int tmp, res = 0, e; + if (v == t) return tmpflow; + for (e = head[v]; e != -1; e = next[e]) + if (flow[e] > 0 && lvl[pt[e]] == lvl[v] + 1) + { + tmp = Update(pt[e], t, MIN(flow[e], tmpflow)); + flow[e] -= tmp; flow[e^1] += tmp; + res += tmp; + tmpflow -= tmp; + if (tmpflow == 0) {break;} + } + lvl[v] = -1; + return res; +} +int dinic(int s, int t) +{ + int res = 0; + while (bfs(s, t)) + res += Update(s, t, INF); + return res; +} +void GenStage(int n) +{ + int i, j, mx = -1; + memset (stage, 0, sizeof stage); + for (i = 0; i < n; i++) + for (j = i + 1; j < n; j++) + if (arr[j] > arr[i]) + stage[j] = MAX(stage[j], stage[i] + 1); + for (i = 0; i < n; i++) + for (j = i + 1; j < n; j++) + if (stage[i] + 1 == stage[j] && arr[i] < arr[j]) + Connect(2 * i + 1, 2 * j, INF); + for (i = 0; i < n; i++) + { + mx = MAX(mx, stage[i]); + } + for (i = 0; i < n; i++) + { + Connect(2 * i, 2 * i + 1, 1); + if (stage[i] == 0) + Connect(2 * n, 2 * i, INF); + if (stage[i] == mx) + Connect(2 * i + 1, 2 * n + 1, INF); + } +} +void Solve() +{ + int i, res; + memset (head, -1, sizeof head); + pos = -1; + scanf("%d", &n); + for (i = 0; i < n; i++) + scanf("%d", arr + i); + GenStage(n); + res = dinic(2 * n, 2 * n + 1); + printf("%d\n", res); +} +int main() +{ + int cas; + scanf("%d", &cas); + while (cas--) + Solve(); + return 0; +} diff --git a/HDOJ/3741_autoAC.cpp b/HDOJ/3741_autoAC.cpp new file mode 100644 index 0000000..d159d37 --- /dev/null +++ b/HDOJ/3741_autoAC.cpp @@ -0,0 +1,72 @@ +#include "iostream" +using namespace std; +struct node +{ + int num,pre; + double weight; +}no[1009]; +double rule[1009],dev; +int e,res; +double w[110],up,down; +bool place(int s) +{ + int i,j,k = e; + double t; + for (i = 0; i < k;i++) + { + t = no[i].weight + w[s]; + if (rule[(int)(t/dev)] == -1 && t <= up) + { + rule[(int)(t/dev)] = t; + no[e].num = s; + no[e].pre = i; + no[e++].weight = t; + if (t >= down) + { + res = e-1; + return true; + } + } + } + return false; +} +int main() +{ + int i,j,k,n; + double sum; + no[0].num = -1; + no[0].weight = 0; + rule[0] = 0; + while (scanf("%d",&n) && n) + { + e = 1; + sum = 0; + for (i = 1;i <= n;i++) + { + scanf("%lf",&w[i]); + sum += w[i]; + } + down = sum /2.01; + up = sum /1.985; + dev = sum/1000; + for (i = 1;i <= 1000;i++) + { + rule[i] = -1; + } + for (i = 1;i <= n;i++) + { + if(place(i)){ + printf("%d",no[res].num); + i = no[res].pre; + while(i > 0) + { + printf(" %d",no[i].num); + i = no[i].pre; + } + printf("\n"); + break; + } + } + } + return 0; +} diff --git a/HDOJ/3742_autoAC.cpp b/HDOJ/3742_autoAC.cpp new file mode 100644 index 0000000..1185fef --- /dev/null +++ b/HDOJ/3742_autoAC.cpp @@ -0,0 +1,40 @@ +#include +#include +using namespace std; +const int maxn = 1000000 + 10; +struct Node{ + int a, b, val; +}node[maxn]; +int parent[maxn]; +bool cmp(const Node &a, const Node &b){ + return a.val < b.val ; +} +void Init(int num){ + for(int i=0; i>n >>m, n||m){ + int ans = 0, i; + for( i=0; i>node[i].a >>node[i].b >>node[i].val; + } + sort(node, node+m, cmp); + Init(n); + for( i=0; i node[i].val ? ans : node[i].val; + parent[ node[i].a ] = -1; + parent[ node[i].b ] = -1; + } + for( i=0; inum-d->num; +} +int sum(int k) +{ + int t=0; + while(k>0) + { + t+=C[k]; + k-=k&(-k); + } + return t; +} +void update(int k,int dir) +{ + while(k>0 && k<=n) + { + C[k]+=dir; + k+=k&(-k); + } +} +int main() +{ + int i; + __int64 ans; + while(scanf("%d",&n)!=-1) + { + for(i=1;i<=n;i++) {scanf("%d",&num[i]);T[i].num=num[i];T[i].index=i;} + T[0].num=-1; + qsort(T,n+1,sizeof(T[0]),cmp); + for(i=1;i<=n;i++) num[T[i].index]=i; + ans=0; + memset(C,0,sizeof(C)); + for(i=1;i<=n;i++) + { + update(num[i],1); + ans+=i-sum(num[i]); + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/3744_autoAC.cpp b/HDOJ/3744_autoAC.cpp new file mode 100644 index 0000000..73d9dd3 --- /dev/null +++ b/HDOJ/3744_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 110 +int t , n , m; +int flag; +int x[MAXN] , r[MAXN]; +int tmp_x[MAXN] , tmp_r[MAXN]; +int search(){ + for(int i = 1 ; i < n ; i++){ + if(tmp_x[i] > tmp_x[i-1]) return i; + } + return 0; +} +void solve(){ + int k; + memset(tmp_ , 0 , sizeof(tmp_x)); + memcpy(tmp_ , r , sizeof(r)); + sort(tmp_ , tmp_r+n); + for(int i = 0 ; i < n ; i++){ + for(int j = 0 ; j < n ; j++){ + if(tmp_r[i] == r[j]){ + tmp_x[i] = x[j] ; break; + } + } + } + while(k = search()){ + for(int i = 0 ; i < k ; i++) tmp_x[i] += 400; + } + if(tmp_x[0] <= m) flag = 1; +} +int main() { + scanf("%d" , &t); + while(t--){ + memset(x , 0 , sizeof(x)); + memset(r , 0 , sizeof(r)); + scanf("%d%d" ,&n , &m); + for(int i = 0 ; i < n ; i++) + scanf("%d%d" , &x[i] , &r[i]); + flag = 0 ; solve(); + if(flag) printf("YES\n"); + else printf("NO\n"); + } + return 0; +} diff --git a/HDOJ/3746_autoAC.cpp b/HDOJ/3746_autoAC.cpp new file mode 100644 index 0000000..20e570e --- /dev/null +++ b/HDOJ/3746_autoAC.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include +using namespace std; +#define N 100010 +char s[N]; +int nextval[N]; +int len; +void getnext(const char *s) +{ + int i = 0, j = -1; + nextval[0] = -1; + while(i != len) + { + if(j == -1 || s[i] == s[j]) + nextval[++i] = ++j; + else + j = nextval[j]; + } +} +int main() +{ + int ncase; + int length, add; + scanf("%d", &ncase); + while(ncase--) + { + scanf("%s", s); + len = strlen(s); + getnext(s); + length = len - nextval[len]; + if(len != length && len % length == 0) + printf("0\n"); + else + { + add = length - nextval[len] % length; + printf("%d\n",add); + } + } + return 0; +} diff --git a/HDOJ/3747_autoAC.cpp b/HDOJ/3747_autoAC.cpp new file mode 100644 index 0000000..03bfa86 --- /dev/null +++ b/HDOJ/3747_autoAC.cpp @@ -0,0 +1,33 @@ +#include"stdio.h" +int min(int a,int b) +{ + return a>b?b:a; +} +int main() +{ + int y1,y2,y3,y4; + int ans; + int i; + int n; + char str1[55],str2[55]; + while(scanf("%d",&n)!=-1) + { + scanf("%s%s",str1,str2); + y1=0; + for(i=0;i +#include +#include +using namespace std; +map ha[35]; +int vis[35]; +int n,v,k; +int flag; +int constraint; +int g[35][35]; +struct node +{ + int w; + int cons; +}t[35],s[35]; +void dfs(int y,int x,int cur) +{ + if(y>k) return; + else if(x==constraint) ha[y][cur]=1; + else + { + int tt=0; + if(s[x].cons!=-1) + { + for(int i=0;ik) return; + else if(x==n) + { + if(ha[k-y][v-cur]==1) + { + flag=1; + return; + } + } + else if(!flag) + { + dfs2(y+1,x+1,cur+s[x].w); + dfs2(y,x+1,cur); + } +} +int main() +{ + int i,j; + int T; + int m; + int mark[35]; + scanf("%d",&T); + while(T--) + { + scanf("%d%d%d%d",&n,&m,&k,&v); + for(i=0;in/2) constraint=cnt; + else constraint=n/2+1; + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define MAXN 111111 +#define MAXM 211111 +#define eps 1e-8 +#define INF 1000000001 +using namespace std; +int e, tmpdfn, top; +int n, m, ind; +int vis[MAXM], head[MAXN], dfn[MAXN], low[MAXN], num[MAXM]; +vectorg[MAXN]; +struct Edge +{ + int v, next; +}edge[MAXM]; +void add(int u, int v) +{ + edge[e].v = v; + edge[e].next = head[u]; + head[u] = e++; + edge[e].v = u; + edge[e].next = head[v]; + head[v] = e++; +} +struct Stack +{ + int s, e; + Stack(){} + Stack(int a, int b){s = a; e = b;} +}st[MAXM]; +void init() +{ + e = tmpdfn = ind = 0; + top = -1; + memset(vis, 0, sizeof(vis)); + memset(dfn, 0, sizeof(dfn)); + memset(head, -1, sizeof(head)); + memset(num, 0, sizeof(num)); +} +void color(Stack t) +{ + ind++; + while(top >= 0) + { + Stack A = st[top--]; + g[A.s].push_back(ind); + g[A.e].push_back(ind); + if(A.s == t.s && A.e == t.e) break; + } +} +void dfs(int u, int fa) +{ + dfn[u] = low[u] = ++tmpdfn; + for(int i = head[u]; i != -1; i = edge[i].next) + { + int v = edge[i].v; + if(vis[i] == 0) + { + vis[i] = vis[i ^ 1] = 1; + Stack tmp(u, v); + st[++top] = tmp; + if(!dfn[v]) + { + dfs(v, u); + low[u] = min(low[u], low[v]); + if(low[v] >= dfn[u]) color(tmp); + } + else if(v != fa) low[u] = min(low[u], dfn[v]); + } + } +} +int Q; +int uu[MAXM], vv[MAXM]; +int fa[MAXN]; +int find(int x) +{ + if(fa[x] == x) return x; + int t = find(fa[x]); + fa[x] = t; + return t; +} +void join(int u, int v) +{ + int fx = find(u); + int fy = find(v); + if(fx != fy) fa[fx] = fy; +} +int main() +{ + int u, v; + int cas = 0; + while(scanf("%d%d%d", &n, &m, &Q) != EOF) + { + if(n == 0 && m == 0 && Q == 0) break; + init(); + for(int i = 1; i <= n; i++) fa[i] = i; + for(int i = 0; i < m; i++) + { + scanf("%d%d", &uu[i], &vv[i]); + uu[i]++; vv[i]++; + add(uu[i], vv[i]); + join(uu[i], vv[i]); + } + for(int i = 1; i <= n; i++) g[i].clear(); + for(int i = 1; i <= n; i++) + { + if(!dfn[i]) dfs(i, 0); + } + for(int i = 1; i <= n; i++) sort(g[i].begin(), g[i].end()); + for(int i = 1; i <= n; i++) unique(g[i].begin(), g[i].end()); + for(int i = 0; i < m; i++) + { + int sz1 = g[uu[i]].size(); + int sz2 = g[vv[i]].size(); + int k1 = 0, k2 = 0; + while(k1 < sz1 && k2 < sz2) + { + if(g[uu[i]][k1] > g[vv[i]][k2]) k2++; + else if(g[uu[i]][k1] < g[vv[i]][k2]) k1++; + else if(g[uu[i]][k1] == g[vv[i]][k2]) + { + int tmp = g[uu[i]][k1]; + num[tmp]++; + break; + } + } + } + printf("Case %d:\n", ++cas); + for(int i = 0; i < Q; i++) + { + scanf("%d%d", &u, &v); + u++; v++; + int sz1 = g[u].size(); + int sz2 = g[v].size(); + int k1 = 0, k2 = 0; + int tmp = -1; + while(k1 < sz1 && k2 < sz2) + { + if(g[u][k1] > g[v][k2]) k2++; + else if(g[u][k1] < g[v][k2]) k1++; + else if(g[u][k1] == g[v][k2]) + { + tmp = g[u][k1]; + break; + } + } + if(find(u) != find(v)) puts("zero"); + else if(tmp == -1) puts("one"); + else if(num[tmp] == 1) puts("one"); + else puts("two or more"); + } + } + return 0; +} diff --git a/HDOJ/3750_autoAC.cpp b/HDOJ/3750_autoAC.cpp new file mode 100644 index 0000000..6df7b91 --- /dev/null +++ b/HDOJ/3750_autoAC.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +double a[100005]; +int main() +{ + int i,j,k; + int N; + a[0]=0; + a[1]=1; + a[2]=3.0; + for(i=3;i<100001;i++) + { + k=(1+i)/2; + a[i]=a[k-1]+k-1+a[i-k]+i-k+1; + } + while(cin>>N) + { + printf("%.2lf\n",a[N]/N); + } + return 0; +} diff --git a/HDOJ/3752_autoAC.cpp b/HDOJ/3752_autoAC.cpp new file mode 100644 index 0000000..7e842ac --- /dev/null +++ b/HDOJ/3752_autoAC.cpp @@ -0,0 +1,17 @@ +#include +using namespace std; +int main() +{ + int n; + scanf("%d", &n); + while(n--) + { + int a, b; + scanf("%d%d", &a, &b); + if(a % 2 == 1|| b > a / 2) + printf("NO\n"); + else + printf("YES\n"); + } + return 0; +} diff --git a/HDOJ/3753_autoAC.cpp b/HDOJ/3753_autoAC.cpp new file mode 100644 index 0000000..36fff0c --- /dev/null +++ b/HDOJ/3753_autoAC.cpp @@ -0,0 +1,40 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +string tmp,str[1111][190]; +int len[190],T,num[1111]; +int main(){ + scanf("%d",&T); + while(T --){ + memset(len,0,sizeof(len)); + memset(num,0,sizeof(num)); + int nNum = 0; + while(getline(cin,tmp) && tmp != "@"){ + if(tmp == "") continue; + istringstream strin(tmp); + int j = 0; + nNum ++; + while(strin >> tmp){ + str[nNum][++ j] = tmp; + if(tmp.size() > len[j]) len[j]= tmp.size(); + } + num[nNum] = j; + } + cout << setiosflags(ios :: left); + for(int i = 1; i <= nNum; i ++){ + for(int j = 1; j < num[i]; j ++){ + cout << setw(len[j] + 1) << str[i][j]; + } + cout << str[i][num[i]] << endl; + } + } + return 0; +} diff --git a/HDOJ/3754_autoAC.cpp b/HDOJ/3754_autoAC.cpp new file mode 100644 index 0000000..e8d7816 --- /dev/null +++ b/HDOJ/3754_autoAC.cpp @@ -0,0 +1,65 @@ +#include +typedef unsigned long long ullong; +int eval(int f[], int x, ullong k){ +bool vst[10]; +for(int i = 0;i < 10; ++i) vst[i] = false; +vst[x] = true; +while(k--){ +x = f[x]; +if(vst[x]){ +int len = 1; +for(int y = f[x];y != x;y = f[y]) ++len; +k %= len; +while(k--) x = f[x]; +return x; +} +else vst[x] = true; +} +return x; +} +int g[10][10]; +ullong min(ullong a, ullong b){ +return a < b ? a : b; +} +int main(){ +int TT; +scanf("%d", &TT); +for(int cas = 1; cas <= TT; ++cas){ +for(int i = 0;i < 10; ++i){ +for(int j = 0;j < 10; ++j){ +scanf("%d", g[j] + i); +} +} +ullong a, b; +scanf("%I64u %I64u", &a, &b); +ullong ans = 0; +for(ullong t = 1;t <= b;t *= 10){ +ullong u = a, v = b; +int d = u / t % 10; +ullong uu = min((u / t + 1) * t - 1, v); +int val = eval(g[d], d, uu - u); +for(++d, u = uu;d < 10 && u < v; ++d, u = uu){ +uu = min(u + t, v); +val = eval(g[d], val, uu - u); +} +if((v - u) / t >= 10){ +int f[10]; +for(int d = 0;d < 10; ++d){ +f[d] = d; +for(int j = 0;j < 10; ++j){ +f[d] = eval(g[j], f[d], t); +} +} +val = eval(f, val, (v - u) / t / 10); +u += (v - u) / t / 10 * t * 10; +} +for(d = 0; u < v; ++d, u = uu){ +uu = min(u + t, v); +val = eval(g[d], val, uu - u); +} +ans += val * t; +} +printf("%I64u\n", ans); +} +return 0; +} diff --git a/HDOJ/3756_autoAC.cpp b/HDOJ/3756_autoAC.cpp new file mode 100644 index 0000000..12429b6 --- /dev/null +++ b/HDOJ/3756_autoAC.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +using namespace std; +#define eps 1e-6 +const double pi = acos(-1.0); +struct Point { + double x, y, z; + double v, h; + void SCANF() { + scanf("%lf %lf %lf", &x, &y, &z); + v = z; + h = sqrt(x*x + y*y); + } +}pt[ 10001 ]; +int n; +double MaxH, MaxV; +double Calc(double R) { + int i; + double Max = 0; + int idx = 0; + for(i = 0; i < n; i++) { + double nv = pt[i].v / (R - pt[i].h); + if(nv > Max) { + Max = nv; + idx = i; + } + } + return Max * R; +} +int main() { + int t; + int i; + scanf("%d", &t); + while(t--) { + scanf("%d", &n); + MaxH = MaxV = 0; + for(i = 0; i < n; i++) { + pt[i].SCANF(); + if(pt[i].h > MaxH) + MaxH = pt[i].h; + if(pt[i].v > MaxV) + MaxV = pt[i].v; + } + double l = MaxH + eps, r = 1e6; + double ml, mr; + while(l + 1e-6 < r) { + ml = (2 * l + r) / 3; + mr = (l + 2 * r) / 3; + double lans = Calc(ml) * ml * ml; + double rans = Calc(mr) * mr * mr; + if( lans > rans ) { + l = ml + 1e-5; + }else + r = mr - 1e-5; + } + double ans = (l + r) / 2; + printf("%.3lf %.3lf\n", Calc(ans), ans); + } + return 0; +} diff --git a/HDOJ/3757_autoAC.cpp b/HDOJ/3757_autoAC.cpp new file mode 100644 index 0000000..1e652ac --- /dev/null +++ b/HDOJ/3757_autoAC.cpp @@ -0,0 +1,74 @@ +#include +#include +#include +#include +using namespace std; +const long long inf=(1LL)<<60; +short path[4010][4010]; +long long f[4010]; +struct node +{ + long long d; + int num; + int sh; +}x[4010],y[4010]; +int n,m; +bool cmpd(node a,node b) +{ + return a.d=1;j--) + { + if(f[j] +#include +#include +#include +#include +#include +#include +#include +#include +#define MAXN 100005 +#define MAXM 400005 +#define INF 1000000011 +#define lch(x) x<<1 +#define rch(x) x<<1|1 +#define lson l,m,rt<<1 +#define rson m+1,r,rt<<1|1 +#define eps 1e-7 +using namespace std; +bool tag[10001]; +int p[10001]; +int cnt; +void get_prime() +{ + cnt = 0; + tag[1] = 1; + for (int i = 2; i < 10000; i++) + { + if (!tag[i]) + p[cnt++] = i; + for (int j = 0; j < cnt && p[j] * i < 10000; j++) + { + tag[i*p[j]] = 1; + if (i % p[j] == 0) + break; + } + } +} +int n, m; +int a[11005], b[11005]; +int numa[10005], numb[10005]; +int ans[1000005]; +int num[1001111]; +void get(int *x, int n, int *num) +{ + for(int i = 1; i <= n; i++) + { + for(int j = 0; j < cnt; j++) + { + int tn = x[i]; + if(tn < p[j]) break; + while(tn){num[j] += tn / p[j]; tn /= p[j];} + } + } +} +bool ok() +{ + for(int i = 0; i < cnt; i++) + if(numb[i] > numa[i]) return 0; + return 1; +} +int main() +{ + int T; + get_prime(); + scanf("%d", &T); + while(T--) + { + scanf("%d%d", &n, &m); + for(int i = 1; i <= n; i++) scanf("%d", &a[i]); + for(int i = 1; i <= m; i++) scanf("%d", &b[i]); + memset(numa, 0, sizeof(numa)); + memset(numb, 0, sizeof(numb)); + get(a, n, numa); + get(b, m, numb); + if(!ok()) + { + printf("-1\n"); + continue; + } + for(int i = 0; i < cnt; i++) numa[i] -= numb[i]; + int tp = 0; + memset(num, 0, sizeof(num)); + while(1) + { + int low = 2, high = 10006; + int can = 0; + while(low <= high) + { + int mid = (low + high) >> 1; + int fg = 1; + for(int j = 0; j < cnt; j++) + { + int tn = mid; + if(tn < p[j]) break; + int sum = 0; + while(tn){sum += tn / p[j]; tn /= p[j];} + if(sum > numa[j]) + { + fg = 0; + break; + } + } + if(fg) {low = mid + 1; can = max(can, mid);} + else high = mid - 1; + } + int x = can; + if(x == 0) break; + ans[tp] = x; + int ot = INF; + for(int j = 0; j < cnt; j++) + { + int tn = x; + if(tn < p[j]) break; + int sum = 0; + while(tn){sum += tn / p[j]; tn /= p[j];} + if(sum > 0) ot = min(ot, numa[j] / sum); + } + num[tp] += ot; + tp++; + for(int j = 0; j < cnt; j++) + { + int tn = x; + if(tn < p[j]) break; + int sum = 0; + while(tn){sum += tn / p[j]; tn /= p[j];} + numa[j] -= ot * sum; + } + } + printf("%d\n", tp); + for(int i =0; i < tp; i++) printf("%d %d\n", ans[i], num[i]); + } + return 0; +} diff --git a/HDOJ/3759_autoAC.cpp b/HDOJ/3759_autoAC.cpp new file mode 100644 index 0000000..9321148 --- /dev/null +++ b/HDOJ/3759_autoAC.cpp @@ -0,0 +1,242 @@ +#include +#include +#include +#include +using namespace std ; +int num[15] ; +int b[10] ; +int temp[10] , cnt = 0; +int p[10] ; +int N ; +int s[10] ; +int st[10] , ed[10] ; +char str[10][3] ; +struct card{ + int a[5] , R; + void insert(int list[]){ + for (int i = 0 ; i < 5 ; i++) + b[i] = list[i] ; + memset(num,0,sizeof(num)); + for (int i = 0 ; i < 5 ; i++) + num[b[i]]++ ; + bool flag = 0 ; + for (int i = 0 ; i < 5 ; i++){ + if (num[b[i]]>1){ + flag=1; + break ; + } + } + if (flag==0){ + sort(b,b+5) ; + for (int i = 0 ; i < 5 ; i++) a[i] = b[i] ; + if (b[0]==2&&b[1]==3) + if (b[2]==4&&b[3]==5) + if (b[4]==14){ + b[4] = 1 ; + sort(b,b+5); + for (int i = 0 ; i < 5 ; i++) + a[i] = b[i] ; + R = 5; + return ; + } + if (b[0]==b[2]-2 && b[1]==b[2]-1) + if (b[3]==b[2]+1 && b[4]==b[2]+2) + { + R = 5 ; + return ; + } + R = 1 ; + return ; + } + int sum2 = 0 , sum3 = 0 , sum4 = 0 ; + for (int i = 2 ; i < 15 ; i++){ + if (num[i]==2) sum2++ ; + if (num[i]==3) sum3++ ; + if (num[i]==4) sum4++ ; + } + if (sum4==1){ + int pos ; + for (int i = 0 ; i < 5 ; i++) + if (num[b[i]] != 4) + pos = i ; + a[0] = b[pos] ; + R = 7 ; + if (pos != 0){ + for (int i = 1 ; i < 5 ; i++) + a[i] = b[0] ; + return ; + } + if (pos != 1){ + for (int i = 1 ; i < 5 ; i++) + a[i] = b[1]; + return ; + } + } + if (sum2 == 1 && sum3 == 1){ + R = 6 ; + for (int i = 0 ; i < 5 ; i++){ + if (num[b[i]] == 3){ + for (int j = 2 ; j < 5 ; j++) + a[j] = b[i] ; + }else + { + for (int j = 0 ; j < 2 ; j++) + a[j] = b[i] ; + } + } + return ; + } + if (sum3 == 1){ + cnt = 0 ; int pos = -1 ; + for (int i = 0 ; i < 5; i++) + if (num[b[i]] != 3) + temp[cnt++] = b[i] ; + else + pos = i ; + for (int i = 2 ; i < 5; i++) + a[i] = b[pos] ; + sort(temp,temp+2); + for (int i = 0 ; i < 2 ; i++) + a[i] = temp[i] ; + R = 4 ; + return ; + } + if (sum2 == 1){ + cnt = 0 ; int pos = -1 ; + for (int i = 0 ; i < 5; i++) + if (num[b[i]] != 2) + temp[cnt++] = b[i] ; + else + pos = i ; + for (int i = 3 ; i < 5; i++) + a[i] = b[pos] ; + sort(temp,temp+3); + for (int i = 0 ; i < 3 ; i++) + a[i] = temp[i] ; + R = 2 ; + return ; + } + R = 3 ; + cnt = 0 ; int pos = -1 ; + for (int i = 0 ; i < 5 ; i++) + if (num[b[i]] != 1) + temp[cnt++] = b[i] ; + else + pos = i ; + a[0] = b[pos] ; + sort(temp,temp+4); + for (int i = 1 ; i < 5 ; i++) + a[i] = temp[i-1]; + } +}state[15*15*15*15*15] ; +void check(){ + if (p[0]==p[1] && p[0]==p[2]) + if (p[0]==p[3] && p[0]==p[4]) + return ; + state[++N].insert(p) ; +} +void dfs(int i){ + if (i > 4){ + check() ; + return ; + } + for (int j = 2 ; j < 15 ; j++) + { + p[i] = j ; + dfs(i+1) ; + } +} +int get(char c){ + if (c>='0' && c<='9') return c - '0' ; + if (c=='T') return 10 ; + if (c=='J') return 11 ; + if (c=='Q') return 12 ; + if (c=='K') return 13 ; + if (c=='A') return 14 ; +} +int Cmp(card &A , card &B){ + if (A.R < B.R) return -1 ; + if (A.R > B.R) return 1 ; + for (int i = 4 ; i >= 0 ; i--){ + if (A.a[i] < B.a[i]) + return -1 ; + if (A.a[i] > B.a[i]) + return 1 ; + } + return 0 ; +} +bool cmp(const card &A , const card &B){ + if (A.R != B.R) return A.R < B.R ; + for (int i = 4 ; i > 0 ; i--) + if (A.a[i] != B.a[i]) + return A.a[i] < B.a[i]; + return A.a[0] < B.a[0] ; +} +int search(int L,int R,card A){ + int ret ; + while (L<=R){ + int mid = (L+R)>>1 ; + if (Cmp(state[mid],A)>=0){ + R = mid - 1 ; + ret = mid ; + }else + L = mid + 1 ; + } + return ret ; +} +int main(){ + N = 0 ; + dfs(0) ; + sort(state+1,state+N+1,cmp); + int cnt = 1 ; + for (int i = 2 ; i <= N ; i++){ + if (Cmp(state[i],state[i-1])==0) continue ; + state[++cnt] = state[i] ; + } + N = cnt ; memset(s,0,sizeof(s)); + memset(st,0,sizeof(st)); + for (int i = 1 ; i <= N ; i++){ + s[state[i].R]++ ; + if (st[state[i].R]==0) st[state[i].R]=i ; + ed[state[i].R] = i ; + } + int Q ; + scanf("%d",&Q) ; + int sum[10]; + sum[0] = 0 ; + for (int i = 1 ; i <= 5 ; i++) + sum[i] = sum[i-1] + s[i] ; + while (Q--){ + for (int j = 0 ; j < 5 ; j++) + scanf("%s",str[j]); + card now ; + for (int j = 0 ; j < 5 ; j++) + b[j] = get(str[j][0]); + now.insert(b); + bool samesuit = true ; + for (int j = 1 ; j < 5 ; j++) + if (str[j][1] != str[0][1]) samesuit = false ; + int rank = now.R ; + int pos = search(st[rank],ed[rank],now) - st[rank] + 1; + int Tonghua = s[1] ; + if (!samesuit){ + if (rank <= 5){ + printf("%d\n",sum[rank-1] + pos) ; + } + else{ + if (rank == 6) + printf("%d\n",sum[5] + Tonghua + pos); + else + printf("%d\n",sum[5] + Tonghua + s[6] + pos) ; + } + }else + { + if (rank == 5){ + printf("%d\n",sum[5] + Tonghua + s[6] + s[7] + pos) ; + } + else + printf("%d\n",sum[5] + pos); + } + } + return 0; +} diff --git a/HDOJ/3760_autoAC.cpp b/HDOJ/3760_autoAC.cpp new file mode 100644 index 0000000..b7d5a66 --- /dev/null +++ b/HDOJ/3760_autoAC.cpp @@ -0,0 +1,120 @@ +#include +using namespace std; +const int maxn = 100005; +const int maxm = 400005; +const int inf = 1000000005; +int head[maxn], vert[maxm], colo[maxm], noxt[maxm], cunt; +int sdis[maxn], edis[maxn], path[maxn], leng; +int queue[maxn], qhead, qtail; +bool vis[maxn], rit[maxn]; +void init(int n) +{ + cunt = 0; + for (int i = 0; i <= n; i++) + { + head[i] = -1; + sdis[i] = -1; + edis[i] = -1; + vis[i] = 0; + rit[i] = 0; + path[i] = inf; + } +} +void addedge(int x, int y, int c) +{ + vert[cunt] = y; + colo[cunt] = c; + noxt[cunt] = head[x]; + head[x] = cunt++; +} +void BFS(int start, int *dis) +{ + dis[start] = 0; + qhead = qtail = 0; + queue[qtail++] = start; + while (qhead < qtail) + { + int x = queue[qhead++]; + for (int p = head[x]; p != -1; p = noxt[p]) + { + int y = vert[p]; + if (-1 == dis[y]) + { + dis[y] = dis[x] + 1; + queue[qtail++] = y; + } + } + } +} +void IdeadPath() +{ + qhead = qtail = 0; + queue[qtail++] = 1; + int step = 0; + while (qhead < qtail) + { + int ttail = qtail; + while (qhead < ttail) + { + int x = queue[qhead++]; + for (int p = head[x]; p != -1; p = noxt[p]) + { + int y = vert[p]; + int c = colo[p]; + if (rit[y] && sdis[y] == step + 1) + { + if (c < path[step]) + { + path[step] = c; + for (int i = ttail; i < qtail; i++) + vis[queue[i]] = 0; + qtail = ttail; + vis[y] = 1; + queue[qtail++] = y; + } + else if (c == path[step] && !vis[y]) + { + vis[y] = 1; + queue[qtail++] = y; + } + } + } + } + step++; + } +} +int main() +{ + int test, cas; + int n, m, a, b, c; + scanf("%d", &test); + for (cas = 1; cas <= test; cas++) + { + scanf("%d %d", &n, &m); + init(n); + for (int i = 0; i < m; i++) + { + scanf("%d %d %d", &a, &b, &c); + if (a == b) continue; + addedge(a, b, c); + addedge(b, a, c); + } + BFS(1, sdis); + BFS(n, edis); + leng = sdis[n]; + for (int i = 1; i <= n; i++) + { + if (sdis[i] + edis[i] == leng) + rit[i] = 1; + } + IdeadPath(); + printf("%d\n", leng); + for (int i = 0; i < leng; i++) + { + if (i) printf(" "); + printf("%d", path[i]); + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/3761_autoAC.cpp b/HDOJ/3761_autoAC.cpp new file mode 100644 index 0000000..9cff9c8 --- /dev/null +++ b/HDOJ/3761_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#define eps 1e-10 +#define N 50005 +#define zero(a) (fabs(a)head+1) + q[m++]=Get_Intersect(deq[head],deq[tail]); +} +int slove(int mid){ + if(n-mid<=2) return 1; + for(int i=0;i +#include +int s[1000005]; +int bin(int x,int n) +{ + int l,h,m; + l = 0; + h = n-1; + m = (l+h/2); + while(l<=h) + { + m = (l+h)/2; + if(xs[m]) + l = m+1; + else + return 1; + } + return 0; +} +int main() +{ + int n,m,i,j,a; + while(~scanf("%d%d",&n,&m),n+m) + { + for(i = 0;i +using namespace std; +#include +#include +#include +#define MAX 1500 +int a[MAX], n; +int main(void) +{ + while(scanf("%d", &n) && n) + { + int i, j; + a[0] = 0; + for(i = 1; i <= n; i++) + scanf("%d", &a[i]); + a[n+1] = 1422; + n = n + 2; + sort(a, a + n); + int flag = 0; + for(i = 0; i + 1 < n; i++) + { + if(a[i+1] - a[i] > 200) + flag = 1; + } + if(a[n - 1] - a[n-2] > 100) flag = 1; + if(flag == 1) + puts("IMPOSSIBLE"); + else puts("POSSIBLE"); + } + return 0; +} diff --git a/HDOJ/3765_autoAC.cpp b/HDOJ/3765_autoAC.cpp new file mode 100644 index 0000000..72a83d3 --- /dev/null +++ b/HDOJ/3765_autoAC.cpp @@ -0,0 +1,43 @@ +#include +#include +int a[200]; +int n; +int ans; +int sum[200]; +void Divide(int p,int differ,int hav) +{ + int i,j,n; + if (differ==0) + { + if (hav>ans) ans=hav; + } + if (p<0) return; + if (abs(differ)>sum[p]) return; + if (sum[p]+hav +#include +int main() +{ + char c[20]; + while(scanf("%s",c),c[0]!='E') + { + int x=0,y,flag=1; + int k; + for(int i=0;c[i];i++) + { + if(c[i]=='-'&&i==0) + flag=-1; + else + x=x*10+c[i]-48; + } + x=x*flag; + scanf("%d",&y); + if(x<0) + x=-x; + if(y<0) + y=-y; + if(y +#include +#include +#include +#include +using namespace std; +struct dot{ + double x, y, r; +}all[1024]; +int n, vis[1024], ok; +double in, out; +void DFS(int u) +{ + if(!ok) return; + vis[u] = 1; + if(all[u].y - all[u].r <= 0) {ok = 0; return;} + for(int v = 0; v < n; ++v) + if(!vis[v] && hypot(all[u].x - all[v].x, all[u].y - all[v].y) < all[u].r + all[v].r) + DFS(v); + if(all[u].x - all[u].r <= 0) + in = min(in, all[u].y - sqrt(all[u].r * all[u].r - all[u].x * all[u].x)); + if(all[u].x + all[u].r >= 1000) + out = min(out, all[u].y - sqrt(all[u].r * all[u].r - (1000-all[u].x) * (1000-all[u].x))); +} +int main() +{ + ios::sync_with_stdio(false); + while(memset(vis, 0, sizeof(vis)), ok = 1, in = out = 1000, cin >> n){ + for(int i = 0; i < n; ++i) + cin >> all[i].x >> all[i].y >> all[i].r; + for(int i = 0; i < n; ++i) + if(!vis[i] && all[i].y + all[i].r >= 1000) + DFS(i); + if(!ok) puts("IMPOSSIBLE"); + else printf("%.2f %.2f %.2f %.2f\n", 0.0, in, 1000.0, out); + } + return 0; +} diff --git a/HDOJ/3768_autoAC.cpp b/HDOJ/3768_autoAC.cpp new file mode 100644 index 0000000..caa70cb --- /dev/null +++ b/HDOJ/3768_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include +using namespace std ; +const int maxn = 100010 ; +const int inf = 0x3f3f3f3f ; +struct Edge +{ + int v ;int w ; + int next ; +}edge[maxn*10] ; +int head[maxn] ; +int dis[20][maxn] ; +int vis[maxn] ; +int nedge ;int a[maxn] ,num; +int n , m ; +void addedge(int u , int v , int w) +{ + edge[nedge].v = v ; + edge[nedge].w = w ; + edge[nedge].next = head[u] ; + head[u] = nedge++ ; +} +void spfa(int st) +{ + queue que ; + memset(vis , 0 ,sizeof(vis)) ; + for(int i = 0;i < n;i++) + dis[st][i] = i == a[st] ? 0 : inf ; + que.push(a[st]) ; + vis[a[st]] = 1; + while(que.size()) + { + int u = que.front() ; + que.pop() ; + vis[u] = 0 ; + for(int i = head[u] ; i != -1 ;i = edge[i].next) + { + int v = edge[i].v ; + if(dis[st][v] > dis[st][u] + edge[i].w) + { + dis[st][v] = dis[st][u] + edge[i].w ; + if(!vis[v]) + vis[v] = 1 , que.push(v) ; + } + } + } +} +int ans = inf ; +void dfs(int pos , int sum , int step) +{ + if(step == num) + { + ans = min(ans , sum + dis[pos][0]) ; + return ; + } + for(int i = 1;i <= num;i++) + if(vis[a[i]])continue ; + else + { + vis[a[i]] = 1; + dfs(i , sum + dis[pos][a[i]] , step + 1) ; + vis[a[i]] = 0 ; + } +} +int main() +{ + int t ; + scanf("%d" ,&t) ; + while(t--) + { + scanf("%d%d" , &n , &m) ; + memset(head , -1 , sizeof(head)) ; + nedge = 0 ; + while(m--) + { + int u , v , w ; + scanf("%d%d%d" , &u , &v ,&w) ; + addedge(u , v , w) ; + addedge(v , u , w) ; + } + scanf("%d" , &num) ; + spfa(0) ; + for(int i = 1;i <= num ; i++) + scanf("%d" , &a[i]) , spfa(i) ; + ans = inf ; + memset(vis , 0 ,sizeof(vis)) ; + dfs(0 , 0 , 0) ; + cout< +#include +#include +using namespace std; +const double eps=1e-10; +const double PI=acos(-1); +int dcmp(double x) +{ + return (x>eps)-(x<-eps); +} +struct Point3 +{ + double x,y,z; + Point3(double x=0,double y=0,double z=0):x(x),y(y),z(z) {} +}; +typedef Point3 Vector3; +Vector3 operator+(Point3 A,Point3 B) +{ + return Point3(A.x+B.x,A.y+B.y,A.z+B.z); +} +Vector3 operator-(Point3 A,Point3 B) +{ + return Point3(A.x-B.x,A.y-B.y,A.z-B.z); +} +Vector3 operator*(Point3 A,double p) +{ + return Point3(A.x*p,A.y*p,A.z*p); +} +Vector3 operator/(Point3 A,double p) +{ + return Point3(A.x/p,A.y/p,A.z/p); +} +bool operator<(Point3 &A,Point3 &B) +{ + return A.x=p-a) return b; + else return a; +} +int main() +{ + int T; + cin>>T; + double a1,b1,a2,b2; + double R=6371009; + double x1,y1,z1,x2,y2,z2; + while(T--) + { + cin>>b1>>a1>>b2>>a2; + b1=b1/180.0*PI; + a1=a1/180.0*PI; + b2=b2/180.0*PI; + a2=a2/180.0*PI; + x1=R*cos(b1)*cos(a1); + y1=R*cos(b1)*sin(a1); + z1=R*sin(b1); + x2=R*cos(b2)*cos(a2); + y2=R*cos(b2)*sin(a2); + z2=R*sin(b2); + Point3 A=Point3(x1,y1,z1); + Point3 B=Point3(x2,y2,z2); + double real_dist=Length(A-B); + Point3 P; + double arc_dist=Angle(A-P, B-P)*R; + printf("%.0lf\n",arc_dist-real_dist); + } +} diff --git a/HDOJ/3774_autoAC.cpp b/HDOJ/3774_autoAC.cpp new file mode 100644 index 0000000..f5726c3 --- /dev/null +++ b/HDOJ/3774_autoAC.cpp @@ -0,0 +1,27 @@ +#include"stdio.h" +int judge(int x,int sum,int max) +{ + if(sum*2>x) return 0; + return x/max+1; +} +int main() +{ + int n; + int p[111],max,sum; + int i; + while(scanf("%d",&n),n) + { + max=0; + sum=0; + for(i=0;imax) max=p[i]; + } + printf("%d ",judge(50,sum,max)); + printf("%d ",judge(60,sum,max)); + printf("%d\n",judge(70,sum,max)); + } + return 0; +} diff --git a/HDOJ/3775_autoAC.cpp b/HDOJ/3775_autoAC.cpp new file mode 100644 index 0000000..6c55b4c --- /dev/null +++ b/HDOJ/3775_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +char str[1000005]; +int drow[8]={0,-1,-1,-1,0,1,1,1}; +int dcol[8]={1,1,0,-1,-1,-1,0,1}; +int main() +{ + __int64 r1,c1,val,r,c,i,j,n; + __int64 s,ans; + while(scanf("%s",str)!=EOF) + { + n=strlen(str); + r=c=s=0; + for (i=0;i +#include +#include +#include +#include +using namespace std; +#define MAXN 110000 +#define INF 10000000 +int d[MAXN], u[MAXN], v[MAXN], w[MAXN], num[10]; +int n, m, e, ve, vMax, vMin; +string input, s; +int ballman_ford() +{ + for(int i = 0; i <= n; d[i++] = INF); + d[0] = 0; + for(int i = 0; i < n; i++){ + for(int j = 0; j < ve; j++) + if(d[v[j]] > d[u[j]] + w[j]) + d[v[j]] = d[u[j]] + w[j]; + } + for(int j = 0; j <= ve; j++) + if(d[v[j]] > d[u[j]] + w[j]) + return 0; + for(int j = 1; j <= n; j++){ + if(vMin > d[j]) vMin = d[j]; + } + return 1; +} +int main() +{ + int i, j, k, l, flag; + while(cin>>n){ + if(!n) break; + cin>>m; + getchar(); + e = 0; + for(i = 0; i < m; i++){ + getline(cin, input); + istringstream in(input); + num[0] = num[1] =num[2] = 0; + for(j = 0, l = 0; in>>s; j++){ + if(isdigit(s[0])){ + for(k = 0; k < s.size(); k++) + num[l] = num[l] * 10 + s[k] - '0'; + l++; + } + if(j == 3){ + if(s == "at") flag = 1; + else flag = 0; + } + } + if(flag){ + u[e] = num[0]; v[e] = num[2]; w[e++] = -num[1]; + }else { + u[e] = num[0]; v[e] = num[2]; w[e++] = 0; + u[e] = num[2]; v[e] = num[0]; w[e++] = num[1]; + } + } + for(i = 1, ve = e; i <= n; i++, ve++){ + u[ve] = 0; v[ve] = i; w[ve] = 0; + } + vMin = 1 << 30; + if(ballman_ford()){ + int minv = 1 << 30; + for (int i = 1; i <= n; i++) { + if (minv > d[i] - vMin) + minv = d[i] - vMin; + } + if (minv == 0) { + for (int i = 1; i <= n; i++) { + printf("%d", d[i] - vMin + 1); + if (i != n) { + printf( + " "); + } + } + printf("\n"); + } else { + for (int i = 1; i <= n; i++) { + printf("%d", d[i] - vMin); + if (i != n) { + printf( + " "); + } + } + printf("\n"); + } + }else printf("Impossible.\n"); + } + return 0; +} diff --git a/HDOJ/3777_autoAC.cpp b/HDOJ/3777_autoAC.cpp new file mode 100644 index 0000000..3426f8a --- /dev/null +++ b/HDOJ/3777_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +using namespace std; +struct Page +{ + int l,r; +}; +bool cmp(Page a,Page b) +{ + if(a.l == b.l)return a.r < b.r; + return a.l < b.l; +} +int main() +{ + int n; + while(scanf("%d", &n), n) + { + char str[1005]= {0},word[1005]= {0}; + Page p[1005]; + getchar(); + gets(str); + int L=strlen(str); + int pos=0,nn=0; + for(int i=0; in) b=n; + if(a<=b) + { + p[nn].l=a; + p[nn].r=b; + nn++; + } + memset(word,0,sizeof(word)); + pos=0; + } + else + word[pos++]=str[i]; + } + sort(p,p+nn,cmp); + int mx=p[0].r,ans=0; + if(nn) ans+=p[0].r-p[0].l+1; + for(int i=1;imx) + { + ans+=p[i].r-p[i].l+1; + mx=p[i].r; + } + else if(p[i].r>mx) + { + ans+=p[i].r-mx; + mx=p[i].r; + } + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3778_autoAC.cpp b/HDOJ/3778_autoAC.cpp new file mode 100644 index 0000000..97fbd70 --- /dev/null +++ b/HDOJ/3778_autoAC.cpp @@ -0,0 +1,146 @@ +#include +#include +#include +using std::sort; +struct dat +{ + int socer; + int top; + int low; + int number; + bool operator<(const dat p)const + { + return p.socerq.socer; +} +int ans[33]; +void dfs(int x) +{ + if(x==q) + { + for(int i=0; ipp) + b[i].top=pp; + if(b[i].lowbb) + a[x].socer+=3; + else if(bb>aa) + a[y].socer+=3; + else if(aa==bb) + a[y].socer++,a[x].socer++; + } + } + dfs(0); + for(int i=0; i +#include +#include +using namespace std; +#define N 1005 +bool ans[N][N]; +int str1[N],str2[N],str3[N*2]; +int n,m,t; +void solve(int n1,int n2) +{ + if(n1>n||n2>m) return ; + if(n1==n&&n2==m) + { + ans[n1][n2]=1; return ; + } + if(ans[n1][n2]) return ; + ans[n1][n2]=1; + if(str3[n1+n2+1]==str1[n1+1]&&!ans[n][n]) + solve(n1+1,n2); + if(str3[n1+n2+1]==str2[n2+1]&&!ans[n][n]) + solve(n1,n2+1); +} +int main() +{ + int i,j,k; + while(scanf("%d%d",&n,&m),n&&m) + { + for(i=1;i<=n;i++) scanf("%d",&str1[i]); + for(i=1;i<=m;i++) scanf("%d",&str2[i]); + for(i=1;i<=n+m;i++) scanf("%d",&str3[i]); + memset(ans,0,sizeof(ans)); + solve(0,0); + if(ans[n][m]) puts("possible"); + else puts("not possible"); + } + return 0; +} diff --git a/HDOJ/3780_autoAC.cpp b/HDOJ/3780_autoAC.cpp new file mode 100644 index 0000000..2678a76 --- /dev/null +++ b/HDOJ/3780_autoAC.cpp @@ -0,0 +1,52 @@ +#include +#include +#include +using namespace std; +const double E = 1e-12; +inline +int dblcmp(double x) +{ + if (x > - E && x < E) + return 0; + return x > 0 ? 1 : -1; +} +int main() +{ + double num[5]; + while (true) { + int cc = 0; + for (int i = 0; i < 3; i++) { + scanf("%lf", &num[i]); + if (dblcmp(num[i]) == 0) + cc++; + } + if (cc == 3) { + break; + } + sort(num, num + 3); + double t = num[0]; + long long h = floor(num[1] + 0.5), l = floor(num[2] + 0.5); + bool ok = false; + if (dblcmp(t - 0.25) >= 0 && h >= 90 && l >= 125) { + if (dblcmp(7 - t) >= 0 && h <= 155 && l <= 290) { + printf("letter\n"); + ok = true; + } else { + if (dblcmp(50 - t) >= 0 && h <= 300 && l <= 380) { + printf("packet\n"); + ok = true; + } else { + double ans = t * 2 + (double)h * 2 + (double)l; + if (dblcmp(ans - 2100) <= 0) { + printf("parcel\n"); + ok = true; + } + } + } + } + if (!ok) { + printf("not mailable\n"); + } + } + return 0; +} diff --git a/HDOJ/3781_autoAC.cpp b/HDOJ/3781_autoAC.cpp new file mode 100644 index 0000000..b28963d --- /dev/null +++ b/HDOJ/3781_autoAC.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +using namespace std; +string num[1001] = {"", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", + "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth", + "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth", "twentieth" +}; +string t[1001] = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", + "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", + "twenty" +}; +string retNum(int val) { + string res; + if(val >= 100) { + res += t[val / 100] + t[100]; + val %= 100; + } + if(val >= 20) { + res += t[val / 10 * 10]; + if(val % 10 != 0) res += t[val % 10]; + return res; + } + return res + t[val]; +} +string getNum(int val) { + string res; + if(val >= 1000) { + res += retNum(val / 1000); + if(val % 1000 == 0) return res + num[1000]; + res += t[1000]; + val %= 1000; + } + if(val >= 100) { + res += retNum(val / 100); + if(val % 100 == 0) return res + num[100]; + res += t[100]; + val %= 100; + } + if(val >= 20) { + if(val % 10 == 0) return res += num[val]; + res += retNum(val / 10 * 10); + return res + num[val % 10]; + } + else { + return res + num[val]; + } +} +void init() +{ + num[30] = "thirtieth";t[30] = "thirty"; + num[40] = "fortieth";t[40] = "forty"; + num[50] = "fiftieth";t[50] = "fifty"; + num[60] = "sixtieth";t[60] = "sixty"; + num[70] = "seventieth";t[70] = "seventy"; + num[80] = "eightieth";t[80] = "eighty"; + num[90] = "ninetieth";t[90] = "ninety"; + num[100] = "hundredth";t[100] = "hundred"; + num[1000] = "thousandth";t[1000] = "thousand"; +} +int judge(string s) +{ + int i,m=0,len=s.length(); + for(i=0;i que; + que.push(getNum(4)); + que.push(getNum(11)); + while(!que.empty()) + { + int i,len; + string str=que.front(); + que.pop(); + len=str.length(); + for(i=0;i +using namespace std; +int main() +{ + int n; + while(cin >> n && n) + { + int cnt = 0; + while(n!=1) + { + if(n%2) + n = (3*n+1)/2; + else + n = n/2; + cnt++; + } + cout << cnt << endl; + } + return 0; +} diff --git a/HDOJ/3783_autoAC.cpp b/HDOJ/3783_autoAC.cpp new file mode 100644 index 0000000..dd2a43e --- /dev/null +++ b/HDOJ/3783_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +using namespace std; +int main() +{ + char str[1000]; + int z,o,j; + while(gets(str)) + { + if(!strcmp(str,"E")) + break; + z = o = j = 0; + int len = strlen(str); + int i; + for(i = 0;i +#include +#include +using namespace std; +int main() +{ + int n; + int a[1005],i,flag[1005]; + while(cin >> n && n) + { + memset(flag,0,sizeof(flag)); + for(i = 0; i> a[i]; + flag[a[i]] = 1; + } + for(i = 0; i1) + { + if(t%2) + t = (t*3+1)/2; + else + t = t/2; + if(t<=1000) + { + flag[t] = 0; + } + } + } + int k = 1; + for(i = n-1; i>=0; i--) + { + if(flag[a[i]]) + { + if(k) + { + cout << a[i]; + k = 0; + } + else + { + cout << " " << a[i]; + } + } + } + cout << endl; + } + return 0; +} diff --git a/HDOJ/3785_autoAC.cpp b/HDOJ/3785_autoAC.cpp new file mode 100644 index 0000000..396065f --- /dev/null +++ b/HDOJ/3785_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +using namespace std; +int a[100010]; +int aux[100010]; +void swap(int *a,int *b){ + int t=*a; + *a=*b; + *b=t; +} +int partition(int a[],int l,int h){ + int i=l; + int j=h+1; + int v=a[l]; + while(1){ + while(a[++i]>v)if(i==h)break; + while(a[--j]=j)break; + swap(&a[i],&a[j]); + } + swap(&a[l],&a[j]); + return j; +} +void q_sort(int a[], int l,int h){ + if(l>=h)return; + int j=partition(a,l,h); + q_sort(a,l,j-1); + q_sort(a,j+1,h); +} +void merge(int a[],int l,int mid,int h){ + int i=l; + int j=mid+1; + for(int k=l;k<=h;++k) + aux[k]=a[k]; + for(int k=l;k<=h;++k){ + if(i>mid)a[k]=aux[j++]; + else if(j>h)a[k]=aux[i++]; + else if(aux[i]>aux[j])a[k]=aux[i++]; + else a[k]=aux[j++]; + } +} +void m_sort(int a[],int l,int h){ + if(h<=l)return ; + int mid=l+(h-l)/2; + m_sort(a , l , mid); + m_sort(a,mid+1,h); + merge(a,l,mid,h); +} +int main(int argc, char *argv[]) +{ + int n,m; + while(scanf("%d%d",&n,&m)==2) + { + memset(a,0,sizeof(a)); + if(n==0&&m==0)return 0; + for(int i=0;i +#include +#include +using namespace std; +int p[26]; +int main() +{ + int n,m; + while(cin>>n>>m) + { + if(n==0&&m==0) break; + memset(p,-1,sizeof(p)); + char c; + char p1; + char p2; + string s; + for(int i=0;i>s; + c=s[0]; + p1=s[1]; + p2=s[2]; + if(p1!='-') p[p1-'A']=c-'A'; + if(p2!='-') p[p2-'A']=c-'A'; + } + char c1,c2; + for(int i=0;i>s; + c1=s[0]; + c2=s[1]; + int count1=0,count2=0; + int target1=c1-'A'; + int target2=c2-'A'; + int cur=target1; + while(cur!=target2) + { + cur=p[cur]; + if(cur==-1) + { + count1=0; + break; + } + else count1++; + } + if(count1==0) + { + cur=target2; + while(cur!=target1) + { + cur=p[cur]; + if(cur==-1) + { + count2=0; + break; + } + else count2++; + } + } + if(count1==0&&count2==0) + { + cout<<'-'<=3) + { + cout<<"great-"; + count1--; + } + cout<<"grandparent"<=3) + { + cout<<"great-"; + count2--; + } + cout<<"grandchild"< +#include +__int64 a,b; +char s1[20],s2[20]; +int len1,len2; +int main() +{ + int i; + while(~scanf("%s%s",s1,s2)) + { + len1 = strlen(s1); + len2 = strlen(s2); + a = b = 0; + for(i = 0; i='0' && s1[i]<='9') + { + a = a*10+s1[i]-'0'; + } + } + if(s1[0] == '-') + a = -a; + for(i=0;i='0' && s2[i]<='9') + b = b*10+s2[i]-'0'; + } + if(s2[0] == '-') + b = -b; + printf("%I64d\n",a+b); + } + return 0; +} diff --git a/HDOJ/3788_autoAC.cpp b/HDOJ/3788_autoAC.cpp new file mode 100644 index 0000000..22ee90d --- /dev/null +++ b/HDOJ/3788_autoAC.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define INF 999999999 +using namespace std; +int main(){ + string s; + while(cin>>s){ + int a=0,b=0,c=0,z=0,i=0; + bool flag=true; + for(;s[i] != 'z' && s[i] != '\0';++i){ + if(s[i] != 'o'){cout<<"Wrong Answer"< +#include +#include +#include +using namespace std; +struct nation +{ + long double gold; + long double all; + long double area; + int id; + int rate1; + int rate2; + int rate3; + int rate4; + int bestrate; + int sortway; +}; +int cmpway; +bool cmp(nation a,nation b) +{ + if(cmpway==0) return a.idb.gold; + else if(cmpway==2) return a.all>b.all; + else if(cmpway==3) return a.gold/a.area>b.gold/b.area; + else if(cmpway==4) return a.all/a.area>b.all/b.area; + } +int main() +{ + int n,m; + bool flag=0; + while(cin>>n>>m) + { + nation p[n]; + vector vn; + double gold,all,area; + for(int i=0;i0) + { + cmpway=1; + sort(vn.begin(),vn.end(),cmp); + for(int i=0;i +#include +#include +#include +using namespace std; +#define INF 0x7fffffff +int n,m; +int map[1005][1005]; +int cost[1005][1005]; +void dijkstra(int st,int ed) +{ + int i,j,v,Min; + int visit[1005],dis[1005],value[1005]; + for(i=1;i<=n;i++) + { + dis[i]=map[st][i]; + value[i]=cost[st][i]; + } + memset(visit,0,sizeof(visit)); + visit[st]=1; + for(i=1;idis[v]+map[v][j]) + { + dis[j]=dis[v]+map[v][j]; + value[j]=value[v]+cost[v][j]; + } + else if(dis[j]==dis[v]+map[v][j]) + { + if(value[j]>value[v]+cost[v][j]) + value[j]=value[v]+cost[v][j]; + } + } + } + } + printf("%d %d\n",dis[ed],value[ed]); +} +int main() +{ + int i,j,st,ed; + int a,b,c,d; + while(scanf("%d%d",&n,&m),n||m) + { + for(i=1;i<=n;i++) + for(j=1;j<=n;j++) + { + map[i][j]=INF; + cost[i][j]=INF; + } + while(m--) + { + scanf("%d%d%d%d",&a,&b,&c,&d); + if(map[a][b]>c) + { + map[a][b]=map[b][a]=c; + cost[a][b]=cost[b][a]=d; + } + else if(map[a][b]==c) + { + if(cost[a][b]>d) + cost[a][b]=cost[b][a]=d; + } + } + scanf("%d%d",&st,&ed); + dijkstra(st,ed); + } + return 0; +} diff --git a/HDOJ/3791_autoAC.cpp b/HDOJ/3791_autoAC.cpp new file mode 100644 index 0000000..850e6be --- /dev/null +++ b/HDOJ/3791_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +typedef struct Node +{ + int data; + struct Node *lc,*rc; +}node,*Link; +int n,f,c,cnt; +char f1[11],la1[11],f2[11],la2[11]; +void insert( Link *L,int x ) +{ + if( *L ) + { + if( x < ( *L ) -> data ) + insert( &( *L ) -> lc , x ); + else + insert( &( *L ) -> rc , x ); + } + else + { + *L = new node; + ( *L ) -> data = x; + ( *L ) -> lc = ( *L ) -> rc = NULL; + } +} +void print1(Link L,char f[] ) +{ + if( L ) + { + f[cnt++] = L ->data + '0'; + print1( L -> lc ,f); + print1( L -> rc ,f); + } +} +void print2( Link L, char la[] ) +{ + if( L ) + { + print2( L -> lc, la ); + print2( L -> rc, la ); + la[cnt++] = L -> data + '0' ; + } +} +int main( ) +{ + while( scanf( "%d",&n ),n ) + { + f = 1; + Link L = NULL; + Link L1 = NULL; + char str[11]; + scanf( "%s",str ); + c = strlen( str ); + for( int i = 0; i < c; ++i ) + insert( &L , str[i] - '0' ); + cnt = 0; + print1( L ,f1); + f1[cnt] = 0; + cnt = 0; + print2( L,la1 ); + la1[cnt] = 0; + for( int i = 0; i < n; ++i ) + { + f = 1; + memset( f2,0,sizeof( f2 ) ); + memset( la2,0,sizeof( la2 ) ); + scanf( "%s",str ); + c = strlen( str ); + for( int i = 0; i < c; ++i ) + insert( &L1, str[i] - '0' ); + cnt = 0; + print1( L1,f2 ); + f2[cnt] = 0; + cnt = 0; + print2( L1,la2 ); + la2[cnt] = 0; + if( strcmp( f1,f2 ) != 0 || strcmp( la1,la2 ) != 0 ) + f = 0; + free( L1 ); + L1 = NULL; + puts( f ? "YES" : "NO" ); + } + free( L ); + L = NULL; + } + return 0; +} diff --git a/HDOJ/3792_autoAC.cpp b/HDOJ/3792_autoAC.cpp new file mode 100644 index 0000000..38714df --- /dev/null +++ b/HDOJ/3792_autoAC.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +int vis[100000+100]; +int prime[80000],c; +int a[100000+10]; +void get_prime() +{ + int i,j,n,m; + c=0; + n=100000; + m=(int)sqrt(n+0.5); + memset(vis,0,sizeof(vis)); + for(i=2;i<=m;i++) if(!vis[i]) + { + for(j=i*i;j<=n;j+=i) vis[j]=1; + } +} +int main() +{ + int i,j,n,max; + get_prime(); + n=0; + a[1]=0;a[0]=0;a[2]=0;a[3]=0;a[4]=0; + for(i=4;i<=100000;i++) + { + if(!vis[i]&&!vis[i-2]) + { + n++; + } + a[i]=n; + } + while(i<=100000) + { + a[i++]=n; + } + while(scanf("%d",&n)!=EOF) + { + if(n<0) break; + printf("%d\n",a[n]); + } + return 0; +} diff --git a/HDOJ/3793_autoAC.cpp b/HDOJ/3793_autoAC.cpp new file mode 100644 index 0000000..5fe9b55 --- /dev/null +++ b/HDOJ/3793_autoAC.cpp @@ -0,0 +1,48 @@ +#include "iostream" +#include "stdio.h" +#include "math.h" +#include "vector" +#include "queue" +#include "memory.h" +#include "algorithm" +#include "string.h" +using namespace std; +#define N 105 +char str[N]; +int Div(int s,int t) +{ + int center=-2; + if(s==t) + center=-1; + bool flag=(t-s+1)%2; + while(t>s&&str[s]==str[t]) + s++,t--; + if(s>t&&!flag)//even + center=-1; + else if(s==t&&flag)//odd + center=s; + return center; +} +int main() +{ + int center1,center2,center; + while(cin>>str&&strcmp(str,"#")!=0) + { + int len=strlen(str); + bool flag=false; + for(int i=0;i=0) + { + for(i=0;i0&&a2[j]>0&&i>=0&&j>=0) + sum+=a1[i--]*a2[j--]; + printf("%I64d\n",sum); + } +}