From 5ed1cf19d0659399e22c594daf0e638778cae88c Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Thu, 1 Sep 2016 20:53:17 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 3200-3299 --- HDOJ/3200_autoAC.cpp | 33 ++++++ HDOJ/3201_autoAC.cpp | 14 +++ HDOJ/3203_autoAC.cpp | 34 ++++++ HDOJ/3205_autoAC.cpp | 105 +++++++++++++++++++ HDOJ/3206_autoAC.cpp | 8 ++ HDOJ/3207_autoAC.cpp | 182 ++++++++++++++++++++++++++++++++ HDOJ/3208_autoAC.cpp | 75 ++++++++++++++ HDOJ/3209_autoAC.cpp | 48 +++++++++ HDOJ/3212_autoAC.cpp | 112 ++++++++++++++++++++ HDOJ/3213_autoAC.cpp | 55 ++++++++++ HDOJ/3215_autoAC.cpp | 140 +++++++++++++++++++++++++ HDOJ/3217_autoAC.cpp | 30 ++++++ HDOJ/3219_autoAC.cpp | 54 ++++++++++ HDOJ/3220_autoAC.cpp | 82 +++++++++++++++ HDOJ/3221_autoAC.cpp | 117 +++++++++++++++++++++ HDOJ/3223_autoAC.cpp | 128 +++++++++++++++++++++++ HDOJ/3225_autoAC.cpp | 97 +++++++++++++++++ HDOJ/3228_autoAC.cpp | 240 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/3229_autoAC.cpp | 110 ++++++++++++++++++++ HDOJ/3231_autoAC.cpp | 85 +++++++++++++++ HDOJ/3232_autoAC.cpp | 17 +++ HDOJ/3233_autoAC.cpp | 70 +++++++++++++ HDOJ/3234_autoAC.cpp | 111 ++++++++++++++++++++ HDOJ/3236_autoAC.cpp | 95 +++++++++++++++++ HDOJ/3240_autoAC.cpp | 93 +++++++++++++++++ HDOJ/3242_autoAC.cpp | 92 +++++++++++++++++ HDOJ/3244_autoAC.cpp | 95 +++++++++++++++++ HDOJ/3245_autoAC.cpp | 93 +++++++++++++++++ HDOJ/3247_autoAC.cpp | 112 ++++++++++++++++++++ HDOJ/3248_autoAC.cpp | 24 +++++ HDOJ/3249_autoAC.cpp | 46 +++++++++ HDOJ/3250_autoAC.cpp | 181 ++++++++++++++++++++++++++++++++ HDOJ/3251_autoAC.cpp | 101 ++++++++++++++++++ HDOJ/3252_autoAC.cpp | 196 +++++++++++++++++++++++++++++++++++ HDOJ/3253_autoAC.cpp | 110 ++++++++++++++++++++ HDOJ/3255_autoAC.cpp | 143 ++++++++++++++++++++++++++ HDOJ/3256_autoAC.cpp | 130 +++++++++++++++++++++++ HDOJ/3257_autoAC.cpp | 77 ++++++++++++++ HDOJ/3259_autoAC.cpp | 70 +++++++++++++ HDOJ/3260_autoAC.cpp | 57 ++++++++++ HDOJ/3262_autoAC.cpp | 89 ++++++++++++++++ HDOJ/3263_autoAC.cpp | 173 +++++++++++++++++++++++++++++++ HDOJ/3264_autoAC.cpp | 73 +++++++++++++ HDOJ/3265_autoAC.cpp | 81 +++++++++++++++ HDOJ/3266_autoAC.cpp | 117 +++++++++++++++++++++ HDOJ/3267_autoAC.cpp | 86 ++++++++++++++++ HDOJ/3268_autoAC.cpp | 88 ++++++++++++++++ HDOJ/3269_autoAC.cpp | 95 +++++++++++++++++ HDOJ/3270_autoAC.cpp | 79 ++++++++++++++ HDOJ/3271_autoAC.cpp | 65 ++++++++++++ HDOJ/3272_autoAC.cpp | 106 +++++++++++++++++++ HDOJ/3274_autoAC.cpp | 58 +++++++++++ HDOJ/3275_autoAC.cpp | 128 +++++++++++++++++++++++ HDOJ/3276_autoAC.cpp | 62 +++++++++++ HDOJ/3277_autoAC.cpp | 230 +++++++++++++++++++++++++++++++++++++++++ HDOJ/3278_autoAC.cpp | 118 +++++++++++++++++++++ HDOJ/3279_autoAC.cpp | 21 ++++ HDOJ/3280_autoAC.cpp | 43 ++++++++ HDOJ/3281_autoAC.cpp | 29 ++++++ HDOJ/3282_autoAC.cpp | 67 ++++++++++++ HDOJ/3283_autoAC.cpp | 20 ++++ HDOJ/3284_autoAC.cpp | 24 +++++ HDOJ/3285_autoAC.cpp | 86 ++++++++++++++++ HDOJ/3286_autoAC.cpp | 82 +++++++++++++++ HDOJ/3287_autoAC.cpp | 70 +++++++++++++ HDOJ/3288_autoAC.cpp | 59 +++++++++++ HDOJ/3289_autoAC.cpp | 131 +++++++++++++++++++++++ HDOJ/3290_autoAC.cpp | 46 +++++++++ HDOJ/3291_autoAC.cpp | 154 +++++++++++++++++++++++++++ HDOJ/3292_autoAC.cpp | 71 +++++++++++++ HDOJ/3293_autoAC.cpp | 56 ++++++++++ HDOJ/3294_autoAC.cpp | 38 +++++++ HDOJ/3295_autoAC.cpp | 184 +++++++++++++++++++++++++++++++++ HDOJ/3296_autoAC.cpp | 42 ++++++++ HDOJ/3297_autoAC.cpp | 95 +++++++++++++++++ HDOJ/3298_autoAC.cpp | 72 +++++++++++++ HDOJ/3299_autoAC.cpp | 89 ++++++++++++++++ 77 files changed, 6789 insertions(+) create mode 100644 HDOJ/3200_autoAC.cpp create mode 100644 HDOJ/3201_autoAC.cpp create mode 100644 HDOJ/3203_autoAC.cpp create mode 100644 HDOJ/3205_autoAC.cpp create mode 100644 HDOJ/3206_autoAC.cpp create mode 100644 HDOJ/3207_autoAC.cpp create mode 100644 HDOJ/3208_autoAC.cpp create mode 100644 HDOJ/3209_autoAC.cpp create mode 100644 HDOJ/3212_autoAC.cpp create mode 100644 HDOJ/3213_autoAC.cpp create mode 100644 HDOJ/3215_autoAC.cpp create mode 100644 HDOJ/3217_autoAC.cpp create mode 100644 HDOJ/3219_autoAC.cpp create mode 100644 HDOJ/3220_autoAC.cpp create mode 100644 HDOJ/3221_autoAC.cpp create mode 100644 HDOJ/3223_autoAC.cpp create mode 100644 HDOJ/3225_autoAC.cpp create mode 100644 HDOJ/3228_autoAC.cpp create mode 100644 HDOJ/3229_autoAC.cpp create mode 100644 HDOJ/3231_autoAC.cpp create mode 100644 HDOJ/3232_autoAC.cpp create mode 100644 HDOJ/3233_autoAC.cpp create mode 100644 HDOJ/3234_autoAC.cpp create mode 100644 HDOJ/3236_autoAC.cpp create mode 100644 HDOJ/3240_autoAC.cpp create mode 100644 HDOJ/3242_autoAC.cpp create mode 100644 HDOJ/3244_autoAC.cpp create mode 100644 HDOJ/3245_autoAC.cpp create mode 100644 HDOJ/3247_autoAC.cpp create mode 100644 HDOJ/3248_autoAC.cpp create mode 100644 HDOJ/3249_autoAC.cpp create mode 100644 HDOJ/3250_autoAC.cpp create mode 100644 HDOJ/3251_autoAC.cpp create mode 100644 HDOJ/3252_autoAC.cpp create mode 100644 HDOJ/3253_autoAC.cpp create mode 100644 HDOJ/3255_autoAC.cpp create mode 100644 HDOJ/3256_autoAC.cpp create mode 100644 HDOJ/3257_autoAC.cpp create mode 100644 HDOJ/3259_autoAC.cpp create mode 100644 HDOJ/3260_autoAC.cpp create mode 100644 HDOJ/3262_autoAC.cpp create mode 100644 HDOJ/3263_autoAC.cpp create mode 100644 HDOJ/3264_autoAC.cpp create mode 100644 HDOJ/3265_autoAC.cpp create mode 100644 HDOJ/3266_autoAC.cpp create mode 100644 HDOJ/3267_autoAC.cpp create mode 100644 HDOJ/3268_autoAC.cpp create mode 100644 HDOJ/3269_autoAC.cpp create mode 100644 HDOJ/3270_autoAC.cpp create mode 100644 HDOJ/3271_autoAC.cpp create mode 100644 HDOJ/3272_autoAC.cpp create mode 100644 HDOJ/3274_autoAC.cpp create mode 100644 HDOJ/3275_autoAC.cpp create mode 100644 HDOJ/3276_autoAC.cpp create mode 100644 HDOJ/3277_autoAC.cpp create mode 100644 HDOJ/3278_autoAC.cpp create mode 100644 HDOJ/3279_autoAC.cpp create mode 100644 HDOJ/3280_autoAC.cpp create mode 100644 HDOJ/3281_autoAC.cpp create mode 100644 HDOJ/3282_autoAC.cpp create mode 100644 HDOJ/3283_autoAC.cpp create mode 100644 HDOJ/3284_autoAC.cpp create mode 100644 HDOJ/3285_autoAC.cpp create mode 100644 HDOJ/3286_autoAC.cpp create mode 100644 HDOJ/3287_autoAC.cpp create mode 100644 HDOJ/3288_autoAC.cpp create mode 100644 HDOJ/3289_autoAC.cpp create mode 100644 HDOJ/3290_autoAC.cpp create mode 100644 HDOJ/3291_autoAC.cpp create mode 100644 HDOJ/3292_autoAC.cpp create mode 100644 HDOJ/3293_autoAC.cpp create mode 100644 HDOJ/3294_autoAC.cpp create mode 100644 HDOJ/3295_autoAC.cpp create mode 100644 HDOJ/3296_autoAC.cpp create mode 100644 HDOJ/3297_autoAC.cpp create mode 100644 HDOJ/3298_autoAC.cpp create mode 100644 HDOJ/3299_autoAC.cpp diff --git a/HDOJ/3200_autoAC.cpp b/HDOJ/3200_autoAC.cpp new file mode 100644 index 0000000..c660fde --- /dev/null +++ b/HDOJ/3200_autoAC.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include +using namespace std; +const int MAX_N = 8, MAX_S = 1 << MAX_N; +int n, m, t, dp[MAX_S][MAX_S]; +char g[MAX_N][MAX_N + 1]; +int main() { + while (scanf("%d", &n) != EOF) { + if (!n) break; + for (int i = 0; i < n; i ++) { + scanf("%s", g[i]); + for (int j = 0; j < n; j ++) g[i][j] -= '0'; + } + int upper = 1 << n, ans = 0; + for (int i = 0; i < n; i ++) { + memset(dp, 0, sizeof(dp)); + dp[1 << i][1 << i] = 1; + for (int mask = 0; mask < upper; mask ++) + for (int s = mask; s; s = (s - 1) & mask) + for (int u = 0; u < n; u ++) if (mask & (1 << u)) + for (int v = 0; v < n; v ++) if ((mask & (1 << v)) == 0 && g[u][v]) { + int m1 = mask | (1 << v); + int m2 = (s | (1 << v)) & (~(1 << u)); + if (((1 << (v + 1)) - 1) >= m2) dp[m1][m2] += dp[mask][s]; + } + for (int s = 0; s < upper; s ++) ans += dp[upper - 1][s]; + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/3201_autoAC.cpp b/HDOJ/3201_autoAC.cpp new file mode 100644 index 0000000..dfb7179 --- /dev/null +++ b/HDOJ/3201_autoAC.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include +#define PI 3.1415926 +int main() +{ + int L; + while((scanf("%d",&L)!=EOF)&&(L!=0)) + { + printf("%.2lf\n",((L*L)/PI)/2.0); + } + return (0); +} diff --git a/HDOJ/3203_autoAC.cpp b/HDOJ/3203_autoAC.cpp new file mode 100644 index 0000000..8dae3b1 --- /dev/null +++ b/HDOJ/3203_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 100005; +int main() +{ + int n; + double a, p, b; + double f0, f1, p0, p1; + while (scanf("%d%lf%lf%lf", &n, &p, &a, &b)) + { + if (n==0 && a==0 && p==0 && b==0) break; + p /= 100.0; + f0 = min(a, b); + f1 = 0.0; + for (int i = 1; i< n; ++i) + { + p0 = min(f0+b, a+p*f0+(1.0-p)*f1); + p1 = p*f0+(1.0-p)*f1; + f0 = p0; + f1 = p1; + } + printf("%.4lf\n", f1); + } + return 0; +} diff --git a/HDOJ/3205_autoAC.cpp b/HDOJ/3205_autoAC.cpp new file mode 100644 index 0000000..ef8b6df --- /dev/null +++ b/HDOJ/3205_autoAC.cpp @@ -0,0 +1,105 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +map tmp; +set > ans[1010]; +int a[1010],b[1010],c[1010]; +bool cmp(vector > A,vector > B) +{ + vector >::reverse_iterator pA=A.rbegin(),pB=B.rbegin(); + while (1) + { + if (pA->firstfirst) return true; + if (pA->first>pB->first) return false; + if (abs(pA->second)second)) return true; + if (abs(pA->second)>abs(pB->second)) return false; + if (pA->secondsecond) return true; + if (pA->second>pB->second) return false; + ++pA;++pB; + } +} +void init() +{ + tmp[1]=1; + tmp[0]=-1; + ans[1].insert(tmp); + for (int i=2;i<=1001;++i) + { + for (int j=1;j >::iterator p=ans[j].begin();p!=ans[j].end();++p) + ans[i].insert(*p); + for (int j=0;j<=i;++j) a[j]=0; + a[i]=1; + a[0]=-1; + for (set >::iterator p=ans[i].begin();p!=ans[i].end();++p) + { + for (int j=0;j<=i;++j) b[j]=c[j]=0; + for (std::_Rb_tree_const_iterator > it=p->begin();it!=p->end();++it) + b[it->first]=it->second; + int get=0; + for (int j=0;j<=i;++j) if (b[j]) get=j; + for (int j=i;j>=0;--j) + if (a[j]) + { + c[j-get]=a[j]; + for (int k=get;k>=0;--k) + a[j-get+k]-=c[j-get]*b[k]; + } + for (int j=i;j>=0;--j) a[j]=c[j]; + } + tmp.clear(); + for (int j=i;j>=0;--j) + if (a[j]) tmp[j]=a[j]; + ans[i].insert(tmp); + } +} +void work() +{ + while (1) + { + int n; + scanf("%d",&n); + if (!n) return; + vector > > v; + v.clear(); + vector > w; + for (set >::iterator p=ans[n].begin();p!=ans[n].end();++p) + { + w.clear(); + for (std::_Rb_tree_const_iterator > it=p->begin();it!=p->end();++it) + w.push_back(make_pair(it->first,it->second)); + v.push_back(w); + } + sort(v.begin(),v.end(),cmp); + for (vector > >::iterator p=v.begin();p!=v.end();++p) + { + w=*p; + putchar('('); + int flag=0; + for (vector >::reverse_iterator it=w.rbegin();it!=w.rend();++it) + { + if (flag) putchar((it->second>0)?'+':'-'); + it->second=abs(it->second); + if (it->first==0) printf("%d",it->second); + else if (it->first==1) (it->second==1)?putchar('x'):printf("%dx",it->second); + else (it->second==1)?printf("x^%d",it->first):printf("%dx^%d",it->second,it->first); + flag=1; + } + putchar(')'); + } + puts(""); + } +} +int main() +{ + init(); + work(); + return 0; +} diff --git a/HDOJ/3206_autoAC.cpp b/HDOJ/3206_autoAC.cpp new file mode 100644 index 0000000..4a2f762 --- /dev/null +++ b/HDOJ/3206_autoAC.cpp @@ -0,0 +1,8 @@ +........ +........ +........ +........ +........ +..43366. +..121556 +44212335 diff --git a/HDOJ/3207_autoAC.cpp b/HDOJ/3207_autoAC.cpp new file mode 100644 index 0000000..867bd17 --- /dev/null +++ b/HDOJ/3207_autoAC.cpp @@ -0,0 +1,182 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +#define lson l, m, rt << 1 +#define rson m + 1, r, rt << 1 | 1 +const int maxn = 100001; +const int segCnt = 400; +const int inf = 0x7f7f7f7f; +int INIT, segLen = segCnt; +struct Segment { + int e[segCnt]; + int Min; + int add; + int addTo; + int lowest; + void init() { + Min = INIT; + for (int i = 0; i < segLen; i++) { + e[i] = INIT; + } + add = addTo = lowest = 0; + } + void update() { + Min = inf; + for (int i = 0; i < segLen; i++) { + if (e[i] <= abs(lowest)) e[i] = 0; + if (e[i]) { + e[i] += add; + e[i] = max(e[i], addTo); + } + Min = min(Min, e[i]); + } + add = addTo = lowest = 0; + } + void Add(int l, int r, int d) { + for (int i = l; i <= r; i++) { + if (e[i]) { + e[i] = max(e[i] + d, 0); + } + } + Min = inf; + for (int i = 0; i < segLen; i++) { + Min = min(Min, e[i]); + } + } + void AddTo(int l, int r, int d) { + for (int i = l; i <= r; i++) { + if (e[i]) { + e[i] = max(e[i], d); + } + } + Min = inf; + for (int i = 0; i < segLen; i++) { + Min = min(Min, e[i]); + } + } + void show() { + puts("Elements: "); + for (int i = 0; i < segLen; i++) { + printf(" %d", e[i]); + } + puts(""); + printf("min %d add %d addto %d lowest %d\n", Min, add, addTo, lowest); + puts("~~~"); + } +} seg[segCnt]; +bool noBreak(int _l, int _r) { + int segL = _l / segLen, segR = _r / segLen; + int restL = _l % segLen, restR = _r % segLen; + if (segL != segR) { + seg[segL].update(); + seg[segR].update(); + for (int i = restL; i < segLen; i++) { + if (!seg[segL].e[i]) return false; + } + for (int i = 0; i <= restR; i++) { + if (!seg[segR].e[i]) return false; + } + for (int i = segL + 1; i < segR; i++) { + if (!seg[i].Min) return false; + } + } else { + seg[segL].update(); + for (int i = restL; i <= restR; i++) { + if (!seg[segL].e[i]) return false; + } + } + return true; +} +void Add(int _l, int _r, int _d) { + int segL = _l / segLen, segR = _r / segLen; + int restL = _l % segLen, restR = _r % segLen; + if (segL != segR) { + seg[segL].update(); + seg[segR].update(); + seg[segL].Add(restL, segLen - 1, _d); + seg[segR].Add(0, restR, _d); + for (int i = segL + 1; i < segR; i++) { + seg[i].add += _d; + if (seg[i].Min) seg[i].Min += _d; + if (seg[i].addTo) seg[i].addTo += _d; + } + } else { + seg[segL].update(); + seg[segL].Add(restL, restR, _d); + } +} +bool Sub(int _l, int _r, int _d) { + if (noBreak(_l, _r)) { + int segL = _l / segLen, segR = _r / segLen; + int restL = _l % segLen, restR = _r % segLen; + if (segL != segR) { + seg[segL].update(); + seg[segR].update(); + seg[segL].Add(restL, segLen - 1, -_d); + seg[segR].Add(0, restR, -_d); + for (int i = segL + 1; i < segR; i++) { + seg[i].add -= _d; + seg[i].addTo = max(seg[i].addTo - _d, 0); + seg[i].Min = max(seg[i].Min - _d, 0); + if (!seg[i].addTo) seg[i].lowest = min(seg[i].lowest, seg[i].add); + } + } else { + seg[segL].update(); + seg[segL].Add(restL, restR, -_d); + } + return true; + } + return false; +} +void AddTo(int _l, int _r, int _d) { + int segL = _l / segLen, segR = _r / segLen; + int restL = _l % segLen, restR = _r % segLen; + if (segL != segR) { + seg[segL].update(); + seg[segR].update(); + seg[segL].AddTo(restL, segLen - 1, _d); + seg[segR].AddTo(0, restR, _d); + for (int i = segL + 1; i < segR; i++) { + if (seg[i].Min < _d && seg[i].addTo < _d) { + seg[i].addTo = _d; + if (seg[i].Min) seg[i].Min = _d; + } + } + } else { + seg[segL].update(); + seg[segL].AddTo(restL, restR, _d); + } +} +int main() { + int N, M; + while (~scanf("%d%d%d", &N, &M, &INIT) && (N + M + INIT)) { + segLen = (int)sqrt((double) N) + 1; + int op, a, b, c; + int cnt = 0; + for (int i = 0; i < segLen; i++) { + seg[i].init(); + } + for (int i = 1; i <= M; i++) { + scanf("%d%d%d%d", &op, &a, &b, &c); + switch (op) { + case 1 : + if (Sub(a, b, c)) { + cnt++; + } + break; + case 2 : + Add(a, b, c); + break; + case 3 : + AddTo(a, b, c); + break; + } + } + printf("%d\n", cnt); + } + return 0; +} diff --git a/HDOJ/3208_autoAC.cpp b/HDOJ/3208_autoAC.cpp new file mode 100644 index 0000000..e904188 --- /dev/null +++ b/HDOJ/3208_autoAC.cpp @@ -0,0 +1,75 @@ +#include +#include +#include +#include +#define ll __int64 +#define inf (ll) 1e18+300 +#define eps 1e-9 +using namespace std; +ll why=(ll)1<<31; +ll num[100]; +ll quickpow(ll m,int n) +{ + ll b=1;int k=n; + while (n>0) + { + if (n&1) + { + double judge=1.0*(inf)/b; + if (judge>1; + if (m>why&&n>0) return -1; + m=m*m; + } + return b; +} +ll find(ll x,int k) +{ + ll l=1,r=(ll)pow(x,1.0/k); + ll tt,pp,qq; + pp=quickpow(r,k); + if (pp==x) return r; + if (pp>x||pp==-1) --r; + else + { + tt=quickpow(r+1,k); + if (tt!=-1&&tt<=x) ++r; + } + return r; +} +ll f(ll x) +{ + int i,j,k; + ll ans=0; + if (x<=3) return x; + memset(num,0,sizeof(num)); + num[1]=x; + for (i=2;i<63;++i) + { + num[i]=find(x,i)-1; + if (!num[i]) break; + } + k=i; + for (i=k-1;i>0;--i) + { + for (j=1;j +#include +#include +#include +#include +using namespace std; +const double PI = acos(-1.0); +int l1, l2, l3, m1, m2, m3; +int hh, mm, ss; +int st, ed; +struct point_t { + double x, y; + point_t() {} + point_t(double _x, double _y) { x = _x, y = _y; } +}; +double dist(const point_t &a, const point_t &b) { + return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); +} +point_t calc(int t) { + double a = 2.0 * PI * t / 43200.0; + double b = 2.0 * PI * t / 3600.0; + double c = 2.0 * PI * t / 60.0; + double ra = m1 * 1.0 / (m1 + m2 + m3); + double rb = m2 * 1.0 / (m1 + m2 + m3); + double rc = m3 * 1.0 / (m1 + m2 + m3); + point_ A(l1 * ra * cos(a), l1 * ra * sin(a)); + point_ B(l2 * rb * cos(b), l2 * rb * sin(b)); + point_ C(l3 * rc * cos(c), l3 * rc * sin(c)); + return point_t(A.x + B.x + C.x, A.y + B.y + C.y); +} +int main() { + while (scanf("%d", &l1) != EOF && l1 != -1) { + scanf("%d%d%d%d%d", &l2, &l3, &m1, &m2, &m3); + scanf("%d:%d:%d", &hh, &mm, &ss); + st = hh * 3600 + mm * 60 + ss; + scanf("%d:%d:%d", &hh, &mm, &ss); + ed = hh * 3600 + mm * 60 + ss; + double ans = 0.0; + point_t pre = calc(st); + for (int t = st + 1; t <= ed; t ++) { + point_t now = calc(t); + ans += dist(pre, now); + pre = now; + } + printf("%.2lf\n", ans * 0.5); + } + return 0; +} diff --git a/HDOJ/3212_autoAC.cpp b/HDOJ/3212_autoAC.cpp new file mode 100644 index 0000000..60e9167 --- /dev/null +++ b/HDOJ/3212_autoAC.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +using namespace std; +#define maxn 105 +#define type int +const int inf = ~0u >> 1; +struct edge +{ + int u,v; + type cost; + edge(){} + edge(int _u,int _v,type _c):u(_u),v(_v),cost(_c){} +}e[maxn * maxn]; +int pre[maxn],id[maxn],vis[maxn]; +type in[maxn]; +type dirmst(int root,int nv,int ne) +{ + type ret = 0; + while(1) + { + fill(in,in + nv,inf); + for(int i = 0;i < ne;i++) + { + int u = e[i].u; + int v = e[i].v; + if(e[i].cost < in[v] && u != v) + { + pre[v] = u; + in[v] = e[i].cost; + } + } + for(int i = 0;i < nv;i++) + { + if(i == root) + continue; + if(in[i] == inf) + return -1; + } + int cntnode = 0; + fill(id,id + nv,-1); + fill(vis,vis + nv,-1); + in[root] = 0; + for(int i = 0;i < nv;i++) + { + ret += in[i]; + int v = i; + while(vis[v] != i && id[v] == -1 && v != root) + { + vis[v] = i; + v = pre[v]; + } + if(v != root && id[v] == -1) + { + for(int u = pre[v]; u != v;u = pre[u]) + id[u] = cntnode; + id[v] = cntnode++; + } + } + if(cntnode == 0) + break; + for(int i = 0;i < nv;i++) + if(id[i] == -1) + id[i] = cntnode++; + for(int i = 0;i < ne;i++) + { + int v = e[i].v; + e[i].u = id[e[i].u]; + e[i].v = id[e[i].v]; + if(e[i].u != e[i].v) + e[i].cost -= in[v]; + } + nv = cntnode; + root = id[root]; + } + return ret; +} +int main() +{ + int n; + while(scanf("%d",&n) == 1 && n) + { + map M; + M["THE_WINDY"] = 2; + int cnt = 3; + string a,b; + int w1,w2; + int m = 0; + int tot = 0; + for(int i = 0;i < n;i++) + { + cin >> a >> w1 >> b >> w2; + if(M[a] == 0) + M[a] = cnt++; + if(M[b] == 0) + M[b] = cnt++; + e[m++] = edge(1,M[a],w1); + tot += w1; + if(M[a] != M[b]) + { + e[m++] = edge(M[b],M[a],w2); + tot += w2; + } + } + e[m++] = edge(0,1,tot + 1); + e[m++] = edge(0,2,tot + 1); + int ans = dirmst(0,cnt,m); + printf("%d\n",ans - (tot + 1) * 2); + } +} diff --git a/HDOJ/3213_autoAC.cpp b/HDOJ/3213_autoAC.cpp new file mode 100644 index 0000000..31fc3fd --- /dev/null +++ b/HDOJ/3213_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +#include +using namespace std; +const int N=1000; +int a1[N],p1[N],a2[N],p2[N],res[N],a[N],b[N]; +int m; +void dp(int k) +{ + int i,j; + memset(res,-1,sizeof(res)); + res[0]=0; + while (k>0) + { + if (k&1) + { + for (i=0; i<=m; i++) b[i]=res[i]; + memset(res,-1,sizeof(res)); + for (i=0; i<=m; i++) + for (j=0; j<=i; j++) + if (b[j]>-1 && a[i-j]>-1) + res[i]=max(res[i],b[j]+a[i-j]); + } + for (i=0; i<=m; i++) b[i]=a[i]; + memset(a,-1,sizeof(a)); + for (i=0; i<=m; i++) + for (j=0; j<=i/2; j++) + if (b[j]>-1 && b[i-j]>-1) + a[i]=max(a[i],b[j]+b[i-j]); + k>>=1; + } +} +int main() +{ + int n,n1,n2,i,j,ans; + while (scanf("%d%d",&n,&m)==2) + { + if (n==0 && m==0) break; + scanf("%d",&n1); + for (i=1; i<=n1; i++) scanf("%d%d",&a1[i],&p1[i]); + scanf("%d",&n2); + for (i=1; i<=n2; i++) scanf("%d%d",&a2[i],&p2[i]); + memset(a,-1,sizeof(a)); + for (i=1; i<=n1; i++) + for (j=1; j<=n2; j++) + if (a1[i]+a2[j]<=m) + a[a1[i]+a2[j]]=max(a[a1[i]+a2[j]],p1[i]+p2[j]); + dp(n); + ans=0; + for (i=0; i<=m; i++) ans=max(ans,res[i]); + printf("%d\n",ans); + } +} diff --git a/HDOJ/3215_autoAC.cpp b/HDOJ/3215_autoAC.cpp new file mode 100644 index 0000000..074c230 --- /dev/null +++ b/HDOJ/3215_autoAC.cpp @@ -0,0 +1,140 @@ +#include +#include +#include +#define eps 1e-12 +int ans[10005][10]; +void init() +{ + double t,x,a; + int i,k; + ans[0][1]=1; + for(i=1;i<=10000;i++) + { + x=(double)i; + t=x*log10(2.0)-floor(x*log10(2.0)); + a=pow(10.0,t); + k=(int)(a+eps); + if(k==1) + { + ans[i][1]=ans[i-1][1]+1; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==2) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]+1; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==3) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]+1; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==4) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]+1; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==5) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]+1; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==6) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]+1; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==7) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]+1; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]; + } + if(k==8) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]+1; + ans[i][9]=ans[i-1][9]; + } + if(k==9) + { + ans[i][1]=ans[i-1][1]; + ans[i][2]=ans[i-1][2]; + ans[i][3]=ans[i-1][3]; + ans[i][4]=ans[i-1][4]; + ans[i][5]=ans[i-1][5]; + ans[i][6]=ans[i-1][6]; + ans[i][7]=ans[i-1][7]; + ans[i][8]=ans[i-1][8]; + ans[i][9]=ans[i-1][9]+1; + } + } +} +int main() +{ + init(); + int n,i; + while(scanf("%d",&n)!=EOF) + { + if(n==-1) + break; + for(i=1;i<9;i++) + printf("%d ",ans[n][i]); + printf("%d\n",ans[n][9]); + } + return 0; +} diff --git a/HDOJ/3217_autoAC.cpp b/HDOJ/3217_autoAC.cpp new file mode 100644 index 0000000..af68836 --- /dev/null +++ b/HDOJ/3217_autoAC.cpp @@ -0,0 +1,30 @@ +#include +#include +#include +#include +using namespace std; +#define maxn 18 +int dp[maxn][1<<18]; +int N, M, s, v; +int main(){ + while(scanf("%d", &N) && N){ + scanf("%d", &M); + memset(dp, 0, sizeof(dp)); + for(int i = 1; i <= M; i++){ + scanf("%d%d", &s, &v); + dp[0][s] = v; + } + for(int i = 1; i <= N; i++){ + for(int sta = 0; sta < (1< max) max = dp[N][sta]; + } + printf("%d\n", max); + } + return 0; +} diff --git a/HDOJ/3219_autoAC.cpp b/HDOJ/3219_autoAC.cpp new file mode 100644 index 0000000..dfc4488 --- /dev/null +++ b/HDOJ/3219_autoAC.cpp @@ -0,0 +1,54 @@ +#include +#include +using namespace std; +int zhengc[101],yanchi[101]; +int times[101],timee[101]; +int ts,te; +int main(){ + int n; + while(scanf("%d",&n)&&n){ + int a,b,c,d,i; + for(i=1;i<=n;i++){ + scanf("%d%d",&zhengc[i],&yanchi[i]); + yanchi[i]+=zhengc[i]; + scanf("%d:%d %d:%d",&a,&b,&c,&d); + times[i]=a*60+b; + timee[i]=c*60+d; + } + scanf("%d:%d %d:%d",&a,&b,&c,&d); + ts=a*60+b; + te=c*60+d; + bool mark=true; + int tt; + for(i=1;i<=n;i++){ + tt=ts+zhengc[i]; + if(tt>=1440){ + mark=false; + break; + } + if(tt<=times[i] || ts>=timee[i]){ + ts+=zhengc[i]; + if(ts>=te || ts>=1440){ + mark=false; + break; + } + }else{ + ts+=yanchi[i]; + if(ts>=te || ts>=1440){ + mark=false; + break; + } + } + } + if(mark){ + if(ts +#include +#include +#include +#include +using namespace std; +const int MAX=1<<17; +const int x[32]={0,1,3,11,10,8,10,2,8,9,9,0,0,1,3,11,10,8,9,2,12,13,13,4,14,6,12,4,5,7,15,14}; +const int y[32]={1,3,11,10,8,0,2,3,9,1,11,2,4,5,7,15,14,12,13,6,13,5,15,6,6,7,4,5,7,15,14,12}; +const int aim=((1<<8)-1); +int dist[MAX]; +struct Node +{ + int st; + int depth; +}; +int has(const int& st,const int& op) +{ + return st^((1<<(15-x[op]))|(1<<(15-y[op]))); +} +void bfs() +{ + Node node,next; + queue q; + node.st=aim; + node.depth=0; + dist[aim]=0; + q.push(node); + while(!q.empty()) + { + node=q.front(); + q.pop(); + if(node.depth>3) + break; + next.depth=node.depth+1; + for(int i=0;i<32;i++) + { + if((node.st&(1<<(15-x[i])))!=(node.st&(1<<(15-y[i])))) + { + next.st=has(node.st,i); + if(dist[next.st]==1000) + { + dist[next.st]=next.depth; + q.push(next); + } + } + } + } +} +int main() +{ + int t,cnt=0; + int a; + int st; + for(int i=0;i3) + { + printf("Case #%d: more\n",cnt); + } + else + { + printf("Case #%d: %d\n",cnt,a); + } + } + return 0; +} diff --git a/HDOJ/3221_autoAC.cpp b/HDOJ/3221_autoAC.cpp new file mode 100644 index 0000000..8694557 --- /dev/null +++ b/HDOJ/3221_autoAC.cpp @@ -0,0 +1,117 @@ +# include +# include +# include +# define N 1000005 +int visit[N],prime[N],K; +__int64 P,Phi; +struct matrix{ + __int64 A[2][2]; +}; +void intt() +{ + int i,j; + memset(visit,0,sizeof(visit)); + for(i=2;i<=1000;i++) + { + if(visit[i]==0) + { + for(j=i+i;j<=1000000;j+=i) + { + visit[j]=1; + } + } + } + K=0; + for(j=2;j<=1000000;j++) + if(visit[j]==0) prime[++K]=j; +} +matrix power(matrix ans1,matrix ans2) +{ + int i,j,k; + matrix ans; + for(i=0;i<=1;i++) + { + for(j=0;j<=1;j++) + { + ans.A[i][j]=0; + for(k=0;k<=1;k++) + { + ans.A[i][j]+=ans1.A[i][k]*ans2.A[k][j]; + if(ans.A[i][j]>Phi) + { + ans.A[i][j]=ans.A[i][j]%Phi+Phi; + } + } + } + } + return ans; +} +matrix mod(matrix un,__int64 k) +{ + matrix ans; + ans.A[0][0]=1; + ans.A[0][1]=0; + ans.A[1][0]=0; + ans.A[1][1]=1; + while(k) + { + if(k%2) ans=power(ans,un); + un=power(un,un); + k/=2; + } + return ans; +} +__int64 mod1(__int64 a,__int64 k) +{ + __int64 ans; + ans=1; + while(k) + { + if(k%2) + { + ans=ans*a; + ans%=P; + } + a=a*a; + a%=P; + k/=2; + } + return ans%P; +} +int main() +{ + int i,ncase,t; + __int64 a,b,aa,bb,n,num,num1,num2; + matrix init,ans; + intt(); + scanf("%d",&ncase); + for(t=1;t<=ncase;t++) + { + scanf("%I64d%I64d%I64d%I64d",&a,&b,&P,&n); + printf("Case #%d: ",t); + if(n==1) {printf("%I64d\n",a%P);continue;} + else if(n==2) {printf("%I64d\n",b%P); continue;} + else if(n==3) {printf("%I64d\n",a*b%P);continue;} + if(P==1) {printf("0\n");continue;} + init.A[0][0]=0; + init.A[0][1]=1; + init.A[1][0]=1; + init.A[1][1]=1; + Phi=1; + num=P; + for(i=1;i<=K;i++) + { + if(prime[i]>P) break; + if(P%prime[i]==0) {Phi*=(prime[i]-1);num/=prime[i];} + } + Phi*=num; + ans=mod(init,n-3); + num1=ans.A[1][1]; + num2=ans.A[0][1]+ans.A[1][1]; + if(num2>Phi) num2=num2%Phi+Phi; + aa=mod1(a,num1); + bb=mod1(b,num2); + printf("%I64d\n",aa*bb%P); + } + return 0; +} diff --git a/HDOJ/3223_autoAC.cpp b/HDOJ/3223_autoAC.cpp new file mode 100644 index 0000000..d4ec7ee --- /dev/null +++ b/HDOJ/3223_autoAC.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +ll pow(ll a,ll b,ll mod){ + ll as=1; + while(b){ + if(b&1)as=as*a%mod; + b>>=1; a=a*a%mod; + } + return as; +} +vectoras,f; +ll gcd(ll a,ll b,ll& x,ll& y){ + if(b==0){ + x=1;y=0; + return a; + } + else{ + ll r=gcd(b,a%b,y,x); + y-=a/b*x; + return r; + } +} +void moxianxing(ll a,ll b,ll n){ + ll x,y; + ll d=gcd(a,n,x,y); + as.clear(); + if(b%d==0){ + x%=n;x+=n;x%=n; + as.push_back(x*(b/d)%(n/d)); + for(ll i=1;irec; +ll lisanshu(ll x,ll n,ll m){ + ll s=(ll)(sqrt((double)m)+0.5); + ll cur=1;rec.clear(); + for(int i=0;i +#include +#include +#include +#include +using namespace std; +#define N 300 +int t, n, m, k, ans[N], match[N], num, match2[N]; +bool vst[N][N], re[N], tmp[N]; +vector jeo[N]; +bool find(int id, int limit) +{ + if (id <= limit) return false; + for(int i = 0; i < jeo[id].size(); i++) + if (!tmp[jeo[id][i]]) + { + tmp[jeo[id][i]] = 1; + if (match[jeo[id][i]] == -1 || find(match[jeo[id][i]], limit)) + { + match[jeo[id][i]] = id; + return true; + } + } + return false; +} +bool solve() +{ + memset(match, -1, sizeof(int) * (n + 1)); + for(int i = 1; i <= n; i++) + { + memset(tmp, 0, sizeof(bool) * (n + 1)); + if (!find(i, 0)) return false; + } + return true; +} +bool check(int id, int tar) +{ + if(match[tar] == id) return true; + int key = 0; + for(int i = 1; i <= n; i++) + if ((match2[i] = match[i]) == id) key = i; + int t = match[tar]; match[tar] = id; match[key] = -1; + memset(tmp, 0, sizeof(bool) * (n + 1)); + if (find(t, id)) return true; + else for(int i = 1; i <= n; i++) + match[i] = match2[i]; + return false; +} +bool dfs(int deep) +{ + if (deep == n + 1) + { + num++; if (num == k) + return true; + return false; + } + for(int i = 0; i < jeo[deep].size(); i++) + if (!re[jeo[deep][i]] && check(deep, jeo[deep][i])) + { + ans[deep] = jeo[deep][i]; + re[jeo[deep][i]] = 1; + if (dfs(deep + 1)) return true; + re[jeo[deep][i]] = 0; + } + return false; +} +int main() +{ + scanf("%d", &t); + for(int ca = 1; ca <= t; ca++) + { + scanf("%d%d%d", &n, &m, &k); + for(int i = 1; i <= n; i++) + for(int j =1; j <= n; j++) vst[i][j] = 0; + for(int i = 0; i < m; i++) + for(int j = 1; j <= n; j++) + { + int x;scanf("%d", &x);vst[j][x] = 1; + } + for(int i = 1; i <= n; i++) + { + jeo[i].clear(); + for(int j = 1; j <= n; j++) + if (!vst[i][j]) jeo[i].push_back(j); + sort(jeo[i].begin(), jeo[i].end()); + } + memset(re, 0, sizeof(bool) * (n + 1)); num = 0; + printf("Case #%d:", ca); + if (solve() && dfs(1)) + { + for(int i = 1; i <= n; i++) printf(" %d", ans[i]); + putchar('\n'); + } + else printf(" -1\n"); + } + return 0; +} diff --git a/HDOJ/3228_autoAC.cpp b/HDOJ/3228_autoAC.cpp new file mode 100644 index 0000000..7677f0e --- /dev/null +++ b/HDOJ/3228_autoAC.cpp @@ -0,0 +1,240 @@ +#include +#include +#include +#include +#define eps 1e-6 +#define N 10010 +using namespace std; +struct Point +{ + double x,y; + Point(){} + Point(double a,double b):x(a),y(b){} +}; +struct Line +{ + Point a,b; + Line(){} + Line(Point u,Point v):a(u),b(v){} +}; +struct Info +{ + int n; + Point p[N]; + Line l; + Point fa; +}; +Info a,b; +struct Node +{ + int u,v; + double len; + Node(){} + Node(int u0,int v0,double len0):u(u0),v(v0),len(len0){} +}nod[8*N]; +bool cccc(Node a,Node b) +{ + return a.len < b.len; +} +int nod_n; +int Sig(double a) +{ + return a<-eps?-1:a>eps; +} +Point Intersection(Line u,Line v) +{ + Point ret=u.a; + double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))/ + ((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x)); + ret.x+=(u.b.x-u.a.x)*t; + ret.y+=(u.b.y-u.a.y)*t; + return ret; +} +int cmp(Point a,Point b) +{ + if(a.x==b.x) + return a.y>1; + if(Sig(num-p[mid].y)>=0) + left=mid; + else + right=mid; + } + } + else + { + while(left+1>1; + if(Sig(num-p[mid].x)>=0) + left=mid; + else + right=mid; + } + } + return left; +} +Point operator +(Point a,Point b) +{ + Point tmp; + tmp.x=a.x+b.x; + tmp.y=a.y+b.y; + return tmp; +} +void Init() +{ + double t; + double ax,ay,bx,by,cx,cy,dx,dy; + scanf("%d%d",&a.n,&b.n); + scanf("%lf%lf%lf%lf",&ax,&ay,&bx,&by); + scanf("%lf%lf%lf%lf",&cx,&cy,&dx,&dy); + for(int i=0;i=0) + nod[nod_n++]=Node(i,a.n+b.n-1,Dis(a.p[i],b.p[b.n-1])); + else + { + int pos=Find(y,b.p,b.n-1,1); + double d1=Dis(a.p[i],b.p[pos]); + double d2=Dis(a.p[i],b.p[pos+1]); + nod[nod_n++]=Node(i,a.n+pos,d1); + nod[nod_n++]=Node(i,a.n+pos+1,d2); + } + } + else + { + double x=tp.x; + if(Sig(x-b.p[0].x)<=0) + nod[nod_n++]=Node(i,a.n,Dis(a.p[i],b.p[0])); + else if(Sig(x-b.p[b.n-1].x)>=0) + nod[nod_n++]=Node(i,a.n+b.n-1,Dis(a.p[i],b.p[b.n-1])); + else + { + int pos=Find(x,b.p,b.n-1,2); + double d1=Dis(a.p[i],b.p[pos]); + double d2=Dis(a.p[i],b.p[pos+1]); + nod[nod_n++]=Node(i,a.n+pos,d1); + nod[nod_n++]=Node(i,a.n+pos+1,d2); + } + } + } + for(int i=0;i=0) + nod[nod_n++]=Node(i+a.n,a.n-1,Dis(b.p[i],a.p[a.n-1])); + else + { + int pos=Find(y,a.p,a.n-1,1); + double d1=Dis(b.p[i],a.p[pos]); + double d2=Dis(b.p[i],a.p[pos+1]); + nod[nod_n++]=Node(i+a.n,pos,d1); + nod[nod_n++]=Node(i+a.n,pos+1,d2); + } + } + else + { + double x=tp.x; + if(Sig(x-a.p[0].x)<=0) + nod[nod_n++]=Node(i+a.n,0,Dis(b.p[i],a.p[0])); + else if(Sig(x-a.p[a.n-1].x)>=0) + nod[nod_n++]=Node(i+a.n,a.n-1,Dis(b.p[i],a.p[a.n-1])); + else + { + int pos=Find(x,a.p,a.n-1,2); + double d1=Dis(b.p[i],a.p[pos]); + double d2=Dis(b.p[i],a.p[pos+1]); + nod[nod_n++]=Node(i+a.n,pos,d1); + nod[nod_n++]=Node(i+a.n,pos+1,d2); + } + } + } + for(int i=0;i +#include +#include +#include +const int MAXN = 1000 + 10; +const int INF = 1<<29; +int N, Track[7][MAXN],conflict[128]; +int total[MAXN]; +int max(int x, int y){ + if (x>y) return x; + else return y; +} +void Build_Confliction(){ + int K; + memset(conflict,0,sizeof(int)*128); + scanf("%d",&K); + while (K--){ + int t,i,conf = 0; + scanf("%d",&t); + for (i=1; i<=64; i*=2){ + conf += (t%10)*i; + t = t/10; + } + for (i=0; i<=127; i++){ + conflict[conf|i] = 1; + } + } + return ; +} +void Build_Cut(){ + int t,k; + memset(total, 0, sizeof(int)*MAXN); + for (t=1; t<=N; t++){ + for (k=0; k<=6; k++) + if (Track[k][t]>0) + total[t] |= (1<<(6-k)); + } +} +void init(){ + scanf("%d", &N); + memset(Track, 0, sizeof(int)*7*MAXN); + for (int i=0; i<=6; i++){ + int C; + scanf("%d", &C); + while (C--){ + int t1,t2; + char t3; + scanf("%d%c", &t1, &t3); + if (t3=='-'){ + scanf("%d", &t2); + Track[i][t1] = 3; Track[i][t2] = 4; + for (int j=t1+1; jans) ans = f[N][j]; + return ans; +} +int main(){ + int T,Cases; + scanf("%d", &T); + for (Cases = 1; Cases <= T; Cases++){ + init(); + printf("Case #%d: %d\n", Cases, solve()); + } + return 0; +} diff --git a/HDOJ/3231_autoAC.cpp b/HDOJ/3231_autoAC.cpp new file mode 100644 index 0000000..2c66148 --- /dev/null +++ b/HDOJ/3231_autoAC.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +using namespace std; +#define N 2005 +struct T +{ + int v,next; +}E[3][N*100]; +struct TT +{ + int head,rd,dep; +}V[3][N]; +int top[3],ans,n,m; +void Add_Edge(int k,int u,int v) +{ + E[k][top[k]].v = v; + E[k][top[k]].next = V[k][u].head; + V[k][u].head = top[k]++; + ++V[k][v].rd; +} +bool Top_Sort(int k) +{ + queue Q; + for(int i=1;i<=n;i++) + if(V[k][i].rd == 0) + Q.push(i); + int cnt = 0; + while(!Q.empty()) + { + ++cnt; + int p = Q.front(); + for(int i=V[k][p].head;i!=NULL;i=E[k][i].next) + { + int q = E[k][i].v; + --V[k][q].rd; + if(V[k][q].rd == 0) + { + Q.push(q); + V[k][q].dep = V[k][p].dep + 1; + } + } + Q.pop(); + } + return cnt == n; +} +int main() +{ + int u,v,nn,ncase=0; + char cmd; + while(~scanf("%d%d%*c",&nn,&m),nn) + { + memset(V,0,sizeof(V)); + top[0] = top[1] = top[2] = 1; + n = 2*nn; + for(int k=0;k<3;k++) + for(int i=1;i<=nn;i++) + Add_Edge(k,i,i+nn); + while(m--) + { + scanf("%c%d%d%*c",&cmd,&u,&v); + if(cmd == 'I') + { + for(int k=0;k<3;k++) + { + Add_Edge(k,u,v+nn); + Add_Edge(k,v,u+nn); + } + } + else + Add_Edge(cmd-'X',u+nn,v); + } + printf("Case %d: ",++ncase); + if(!Top_Sort(0) || !Top_Sort(1) || !Top_Sort(2)) + puts("IMPOSSIBLE\n"); + else + { + puts("POSSIBLE"); + for(int i=1;i<=nn;i++) + printf("%d %d %d %d %d %d\n",V[0][i].dep,V[1][i].dep,V[2][i].dep,V[0][i+nn].dep,V[1][i+nn].dep,V[2][i+nn].dep); + puts(""); + } + } + return 0; +} diff --git a/HDOJ/3232_autoAC.cpp b/HDOJ/3232_autoAC.cpp new file mode 100644 index 0000000..6d7d7e8 --- /dev/null +++ b/HDOJ/3232_autoAC.cpp @@ -0,0 +1,17 @@ +#include +int main() +{ + int n, i, cas = 0, d, p, l, v; + while(~scanf("%d%d",&n,&d), n+d) + { + double ans = d*1.0; + for(i = 0; i < n; i++) + { + scanf("%d%d%d",&p, &l, &v); + ans -= l; + ans += 2.0*l / v; + } + printf("Case %d: %.3lf\n\n",++cas, ans); + } + return 0; +} diff --git a/HDOJ/3233_autoAC.cpp b/HDOJ/3233_autoAC.cpp new file mode 100644 index 0000000..851b7f8 --- /dev/null +++ b/HDOJ/3233_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-7; +struct node{ + node(){} + node(double _size,double _rem):size(_size),rem(_rem){} + double size,rem; +}; +node Q[1005],data[20005]; +bool cmp(node a,node b) +{ + if(fabs(a.size-b.size) < eps) return a.rem > b.rem; + return a.size < b.size; +} +double solve(int n,int m,double b) +{ + int len = 0; + double ans = 0; + for(int i = 0;i < n;++i) + { + if(len < m) + { + double Size = data[i].size*(1-data[i].rem*0.01); + if(fabs(Size) < eps) continue; + Q[len++] = node(Size,0.0); + for(int j = len-1;j > 0;--j) + { + if(Q[j].size < Q[j-1].size) + swap(Q[j],Q[j-1]); + else + break; + } + } + if(len == m) + { + double t = Q[0].size / (b / m),s = Q[0].size; + ans += t; + for(int j = 1;j < len;++j) + { + Q[j].size -= s; + Q[j-1] = Q[j]; + } + len--; + } + } + for(int i = 0;i < len;++i) + { + double t = Q[i].size / (b / (len-i)),s = Q[i].size; + ans += t; + for(int j = i;j < len;++j) + Q[j].size -= s; + } + return ans; +} +int main() +{ + int n,m,b,casenum = 1; + while(scanf("%d%d%d",&n,&m,&b) && n+m+b) + { + for(int i = 0;i < n;++i) + scanf("%lf%lf",&data[i].size,&data[i].rem); + sort(data,data+n,cmp); + printf("Case %d: %.2lf\n\n",casenum++,solve(n,m,(double)b)); + } + return 0; +} diff --git a/HDOJ/3234_autoAC.cpp b/HDOJ/3234_autoAC.cpp new file mode 100644 index 0000000..679c3f7 --- /dev/null +++ b/HDOJ/3234_autoAC.cpp @@ -0,0 +1,111 @@ +#include +#include +#include +using namespace std; +int f[20010],r[20010],n; +int map[20010]; +int xp[20],ans; +void init() +{ + for(int i=0;i<=n;i++) + { + f[i]=i; + r[i]=0; + } +} +int find(int x) +{ + if(x==f[x]) + return x; + int t=find(f[x]); + r[x]^=r[f[x]];//规x涓惰圭崇郴姹x涓硅圭崇郴 + f[x]=t; + return f[x]; +} +bool Union(int x,int y,int k) +{ + int a=find(x); + int b=find(y); + if(a==b) + { + if((r[x]^r[y])==k) + return true; + return false; + } + if(a==n) + swap(a,b); + f[a]=b; + r[a]=r[x]^r[y]^k; + return true; +} +bool query(int m) +{ + memset(map,0,sizeof(map)); + for(int i=0;i +#include +#include +using std::sort; +#define inf -2100000000 +#define MAXV1 501 +#define MAXV2 51 +#define MAXN 301 +struct T +{ + int p,v,f; + bool operator < (const T a) const + { + return f>a.f; + } +} gift[MAXN]; +int res[MAXV1][MAXV2][2]; +inline int max (int a,int b,int c=0,int d=0) +{ + return (a>b?a:b)>(c>d?c:d)?(a>b?a:b):(c>d?c:d); +} +int main() +{ + int v1,v2,n,i,j,k,m,ts; + int cas=1; + while (scanf("%d%d%d",&v1,&v2,&n)) + { + if (v1==0&&v2==0&&n==0) break; + memset(res,0,sizeof(res)); + ts=0; + for (i=1; i<=n; ++i) + { + scanf("%d%d%d",&gift[i].p,&gift[i].v,&gift[i].f); + if (gift[i].f==1) ts+=gift[i].v; + } + sort(gift+1,gift+n+1); + for (k=1; k<=n; ++k) + { + if (gift[k].f==0) break; + for (i=v1; i>=0; --i) + { + for (j=v2; j>=0; --j) + { + if (i>=gift[k].p&&j>=gift[k].p) + { + res[i][j][1]=max(res[i][j][0]+gift[k].v,res[i][j-gift[k].p][1]+gift[k].v,res[i-gift[k].p][j][1]+gift[k].v); + res[i][j][0]=max(res[i][j-gift[k].p][0]+gift[k].v,res[i-gift[k].p][j][0]+gift[k].v); + } + else if (i>=gift[k].p) + { + res[i][j][1]=max(res[i][j][0]+gift[k].v,res[i-gift[k].p][j][1]+gift[k].v); + res[i][j][0]=res[i-gift[k].p][j][0]+gift[k].v; + } + else if (j>=gift[k].p) + { + res[i][j][1]=max(res[i][j][0]+gift[k].v,res[i][j-gift[k].p][1]+gift[k].v); + res[i][j][0]=res[i][j-gift[k].p][0]+gift[k].v; + } + else + { + res[i][j][1]=res[i][j][0]+gift[k].v; + } + } + } + } + m=0; + if (res[v1][v2][1]=0; --i) + { + for (j=v2; j>=0; --j) + { + if (res[i][j][0]>=ts) res[i][j][1]=max(res[i][j][1],res[i][j][0]+gift[k].v); + if (j>=gift[k].p&&res[i][j-gift[k].p][0]>=ts) res[i][j][0]=max(res[i][j-gift[k].p][0]+gift[k].v,res[i][j][0]); + if (i>=gift[k].p&&res[i-gift[k].p][j][0]>=ts) res[i][j][0]=max(res[i-gift[k].p][j][0]+gift[k].v,res[i][j][0]); + if (j>=gift[k].p&&res[i][j-gift[k].p][1]>=ts) res[i][j][1]=max(res[i][j-gift[k].p][1]+gift[k].v,res[i][j][1]); + if (i>=gift[k].p&&res[i-gift[k].p][j][1]>=ts) res[i][j][1]=max(res[i-gift[k].p][j][1]+gift[k].v,res[i][j][1]); + } + } + } + for (i=1; i<=v1; ++i) + { + for (j=1; j<=v2; ++j) + { + m=max(m,res[i][j][0],res[i][j][1]); + } + } + } + printf("Case %d: %d\n\n",cas++,m); + } + return 0; +} diff --git a/HDOJ/3240_autoAC.cpp b/HDOJ/3240_autoAC.cpp new file mode 100644 index 0000000..bf663d9 --- /dev/null +++ b/HDOJ/3240_autoAC.cpp @@ -0,0 +1,93 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int N=10001; +typedef long long LL; +int su[N],num[N]; +int n,m,sui; +void mul(LL &res,int k) +{ + for(int i=0;i0) + { + k/=su[i]; + num[i]--; + } + } + if(k!=1) + { + int x,y,temp; + temp=ext_gcd(k,m,x,y); + x=(x%m+m)%m; + res=(res*x)%m; + } +} +int main() +{ + int i,j,k,t; + while(scanf("%d%d",&n,&m)&&(n+m)) + { + sui=0,t=m; + for(i=2;i*i<=t;i++) + if(t%i==0) + { + su[sui++]=i; + while(t%i==0) + t/=i; + } + if(t>1) + su[sui++]=t; + memset(num,0,sizeof(num)); + LL res=1,sum=1,l; + for(i=2;i<=n;i++) + { + mul(res,4*i-2); + chu(res,i+1); + l=res; + for(j=0;j +#include +#include +#include +#include +#include +using namespace std; +const int N = 10005; +char str[N]; +struct node +{ + char s[81]; + int len; + int flag; +}list1[N],list2[N]; +int n1,n2; +int op; +void solve() +{ + int len = strlen(str); + memset(list1,0,sizeof(list1)); + memset(list2,0,sizeof(list2)); + n1 = n2 = 0; + int i,j; + for(i = 1;i < len;) + { + while(str[i] != ',' && str[i] != ']') + list1[n1].s[list1[n1].len ++] = str[i ++]; + list1[n1].s[list1[n1].len] = '\0'; + n1 ++; + if(str[i] == ']') + break; + i ++; + } + i +=2; + if(str[i] == '+') + op = 1; + else + op = 0; + i += 4; + for(;i < len - 1;) + { + while(str[i] != ',' && str[i] != ']') + list2[n2].s[list2[n2].len ++] = str[i ++]; + list2[n2].s[list2[n2].len] = '\0'; + n2 ++; + i ++; + } + if(op == 1) + { + printf("[%s",list1[0].s); + for(i = 1;i < n1;i ++) + printf(",%s",list1[i].s); + for(i = 0;i < n2;i ++) + printf(",%s",list2[i].s); + printf("]\n"); + return; + } + for(i = 0;i < n2;i ++) + { + for(j = 0;j < n1;j ++) + { + if(list1[j].flag) + continue; + if(strcmp(list1[j].s,list2[i].s) == 0) + { + list1[j].flag = 1; + break; + } + } + } + printf("["); + for(j = n1 - 1;j >= 0;j --) + if(list1[j].flag == 0) + break; + for(i = 0;i < j;i ++) + { + if(list1[i].flag == 0) + printf("%s,",list1[i].s); + } + printf("%s]\n",list1[j].s); +} +int main() +{ + while(gets(str)) + { + if(str[0] == '.') + break; + solve(); + } + return 0; +} diff --git a/HDOJ/3244_autoAC.cpp b/HDOJ/3244_autoAC.cpp new file mode 100644 index 0000000..6497996 --- /dev/null +++ b/HDOJ/3244_autoAC.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +#include +using namespace std; +int n,m; +const int maxn = 110; +const int inf = 0x3f3f3f3f; +struct node +{ + int s1,s2; + int p1,p2; + int x,y; +}t[maxn]; +int cal_r() +{ + int ret=inf; + for(int i=1;i<=n;i++) + { + if(t[i].s1*1.0/t[i].p1 >= t[i].s2*1.0/t[i].p2) + { + int tmp = (m/t[i].p1*t[i].s1)+t[i].y; + int p = tmp/t[i].x; + ret=min(ret,p); + } + else + { + int tmp = (m/t[i].p2*t[i].s2)+t[i].y; + int p = tmp/t[i].x; + ret=min(ret,p); + } + } + return ret; +} +int dp[6000000+20]; +int cal_need(int i,int need) +{ + int w[2],c[2]; + c[0]=t[i].p1; + w[0]=t[i].s1; + c[1]=t[i].p2; + w[1]=t[i].s2; + int V=need+t[i].s2; + for(int i=1;i<=V;i++) + dp[i]=inf; + dp[0]=0; + for(int i=0;i<2;i++) + { + for(int v=w[i];v<=V;v++) + dp[v]=min(dp[v],dp[v-w[i]]+c[i]); + } + int ret = inf; + for(int i=need;i<=V;i++) + ret = min(ret,dp[i]); + return ret; +} +bool judge(int k) +{ + int s=0; + for(int i=1;i<=n;i++) + { + int need = t[i].x*k-t[i].y; + if(need<=0) + continue; + int tmp = cal_need(i,need); + s+=tmp; + if(s>m) + return false; + } + return true; +} +int main() +{ + while(~scanf("%d%d",&n,&m) && n+m) + { + for(int i=1;i<=n;i++) + scanf("%d%d%d%d%d%d",&t[i].x,&t[i].y,&t[i].s1,&t[i].p1,&t[i].s2,&t[i].p2); + int r=cal_r(); + int l=0; + int ans = 0; + while(l<=r) + { + int mid=(l+r)>>1; + if(judge(mid)) + { + ans=mid; + l=mid+1; + } + else + r=mid-1; + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3245_autoAC.cpp b/HDOJ/3245_autoAC.cpp new file mode 100644 index 0000000..acbd147 --- /dev/null +++ b/HDOJ/3245_autoAC.cpp @@ -0,0 +1,93 @@ +#include +#include +#include +using namespace std; +#define min(a,b) a>b?b:a +#pragma comment(linker,"/STACK:1000000000,1000000000") +const int maxn = 10010; +const int INF = 1000000000; +int dp[maxn][110]; +int sum[maxn],sumd[maxn]; +int head[maxn]; +struct Edge{ + int v,next; +}edge[2*maxn];int N,L,E; +void add_edge(int a,int b) +{ + edge[E].v=b; + edge[E].next=head[a]; + head[a]=E++; +} +void dfs(int u,int fa) +{ + int i,j,k,v; + sum[u]=1;sumd[u]=0; + fill(dp[u],dp[u]+L+1,INF); + for(i=head[u];i!=-1;i=edge[i].next) + { + v=edge[i].v; + if(v==fa) continue; + dfs(v,u); + sumd[u]+=sumd[v]+sum[v]; + sum[u]+=sum[v]; + } + dp[u][0]=sumd[u]; + for(i=head[u];i!=-1;i=edge[i].next) + { + v=edge[i].v; + if(v==fa) continue; + for(j=1;j<=L;j++) + dp[u][j]=min(dp[u][j],dp[v][j-1]+sumd[u]-sumd[v]-sum[v]); + } +} +int ans[maxn]; +void solve(int u,int fa) +{ + int i,a,v; + if(u==0) ans[u]=sumd[0]; + else ans[u]=N-sum[u]+sumd[fa]-sum[u]; + int tmp[110]; + fill(tmp,tmp+L+1,INF); + int mi=INF; + for( i=head[u];i!=-1;i=edge[i].next) + { + v=edge[i].v; + if(v==fa) continue; + for( a=0;a<=L-2;a++) + mi=min(mi,tmp[L-2-a]+dp[v][a]-sumd[v]-sum[v]); + for( a=0;a<=L-1;a++) + { + tmp[a]=min(tmp[a],dp[v][a]-sumd[v]-sum[v]); + if(a) tmp[a]=min(tmp[a],tmp[a-1]); + } + } + mi=min(mi,tmp[L-1]); + sumd[u]=ans[u]; + ans[u]+=mi; + for(i=head[u];i!=-1;i=edge[i].next) + { + v=edge[i].v; + if(v==fa) continue; + solve(v,u); + } +} +int main() +{ + int i,j,k,a,b; + while(scanf("%d%d",&N,&L),(N||L)) + { + if(N==1) {puts("0");continue;} + E=0; + memset(head,-1,sizeof(head)); + for(i=0;i +#include +#include +#include +#include +#define eps 1e-10 +#define N 100005 +#define inf 1<<20 +#define zero(a) (fabs(a)=0) tree[p].source=1< +int main() +{ + int n,m,n1; + while(scanf("%d",&n)!=EOF&&n!=-1) + { + m=n; + n/=30; + n=15-n; + if(n>=12) + n-=12; + if(m%30==0) + printf("Exactly %d o'clock\n",n); + else + { + if(n==0) + n1=11; + else + n1=n-1; + printf("Between %d o'clock and %d o'clock\n",n1,n); + } + } + return 0; +} diff --git a/HDOJ/3249_autoAC.cpp b/HDOJ/3249_autoAC.cpp new file mode 100644 index 0000000..fd82081 --- /dev/null +++ b/HDOJ/3249_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +using namespace std; +#define inf 0x3f3f3f3f +struct node +{ + int l; + int p; +}a[10005]; +bool cmp(node b,node c) +{ + return b.p=dp[top]+a[i].l?a[i].p:dp[top]+a[i].l); + if(top+1>ans) + ans=top+1; + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3250_autoAC.cpp b/HDOJ/3250_autoAC.cpp new file mode 100644 index 0000000..60308ea --- /dev/null +++ b/HDOJ/3250_autoAC.cpp @@ -0,0 +1,181 @@ +#include +#include +#include +const int MAXN=10; +int hei[10]; +int mp[300]; +int a[30][5]; +int p[100][30]; +char s[100]; +int first,anss; +int Cnt[10]={2,4,4,1,2,4,2}; +int Dx[7][4]= +{ + 0,0,0,0, + 0,-1,-1,-1, + 0,-1,-1,-1, + 0,0,-1,-1, + 0,0,-1,-1, + 0,-1,-1,-1, + 0,0,-1,-1 +}; +int Dy[7][4]= +{ + 0,1,2,3, + 0,0,1,2, + 0,-2,-1,0, + 0,1,0,1, + 0,1,-1,0, + 0,-1,0,1, + 0,1,1,2 +}; +int rotx(int x,int y,int rot) +{ + if (rot==0) return x; + if (rot==1) return y; + if (rot==2) return -x; + if (rot==3) return -y; +} +int roty(int x,int y,int rot) +{ + if (rot==0) return y; + if (rot==1) return -x; + if (rot==2) return -y; + if (rot==3) return x; +} +bool set(int now,int id,int pos,int rot) +{ + for (int i=0; i<4; i++) + { + int dx1=Dx[id][i]; + int dy1=Dy[id][i]; + int dx=rotx(dx1,dy1,rot); + int dy=roty(dx1,dy1,rot); + if (pos+dy<0||pos+dy>=5) return false; + } + int target=0; + for (int ii=MAXN; ii>=0; ii--) + { + for (int i=0; i<4; i++) + { + int dx1=Dx[id][i]; + int dy1=Dy[id][i]; + int dx=rotx(dx1,dy1,rot); + int dy=roty(dx1,dy1,rot); + if (ii+dx<0) + { + target=ii+1; + break; + } + if (a[ii+dx][pos+dy]==1) + { + target=ii+1; + break; + } + } + if (target!=0) break; + } + for (int i=0; i<4; i++) + { + int dx1=Dx[id][i]; + int dy1=Dy[id][i]; + int dx=rotx(dx1,dy1,rot); + int dy=roty(dx1,dy1,rot); + //printf("%d %d\n",pos+dx,target+dy); + a[target+dx][pos+dy]=1; + } + p[now][0]=target; + p[now][1]=0; + for (int i=MAXN; i>=0; i--) + { + bool find=true; + for (int j=0; j<5; j++) + if (a[i][j]!=1) find=false; + if (find) + { + p[now][p[now][1]+2]=i; + for (int j=i; j=0; ii--) + { + int line=p[now][ii+2]; + for (int i=MAXN; i>line; i--) + for (int j=0; j<5; j++) + a[i][j]=a[i-1][j]; + for (int j=0; j<5; j++) + a[line][j]=1; + } + int target=p[now][0]; + for (int i=0; i<4; i++) + { + int dx1=Dx[id][i]; + int dy1=Dy[id][i]; + int dx=rotx(dx1,dy1,rot); + int dy=roty(dx1,dy1,rot); + a[target+dx][pos+dy]=0; + } +} +void dfs(int now,int end) +{ + if (now==end) + { + int ans=0; + for (int i=0; i<5; i++) + { + int max=0; + for (int j=MAXN; j>=0; j--) + if (a[j][i]==1) + { + max=(j+1); + break; + } + ans+=max*max; + } + if (first||ans +#include +#include +#define MAXD 1010 +#define MAXM 202010 +#define INF 0x3f3f3f3f +int N, M, F, first[MAXD], e, next[MAXM], v[MAXM], flow[MAXM], id[MAXM], MAX; +int S, T, d[MAXD], q[MAXD], work[MAXD], Q; +void add(int x, int y, int z, int i) +{ + v[e] = y, flow[e] = z, id[e] = i; + next[e] = first[x], first[x] = e ++; +} +void init() +{ + int i, x, y, z; + scanf("%d%d%d", &N, &M, &F); + S = 1, T = N + 1; + memset(first, -1, sizeof(first[0]) * (T + 1)), e = 0; + for(i = 1; i <= M; i ++) + { + scanf("%d%d%d", &x, &y, &z); + add(x, y, z, i), add(y, x, 0, i); + } + MAX = 0; + for(i = 0; i < F; i ++) + { + scanf("%d%d", &x, &y), MAX += y; + add(x, T, y, 0), add(T, x, 0, 0); + } +} +int bfs() +{ + int i, j, rear = 0; + memset(d, -1, sizeof(d[0]) * (T + 1)); + d[S] = 0, q[rear ++] = S; + for(i = 0; i < rear; i ++) + for(j = first[q[i]]; j != -1; j = next[j]) + if(flow[j] && d[v[j]] == -1) + { + d[v[j]] = d[q[i]] + 1, q[rear ++] = v[j]; + if(v[j] == T) return 1; + } + return 0; +} +int dfs(int cur, int a) +{ + if(cur == T) return a; + for(int &i = work[cur]; i != -1; i = next[i]) + if(flow[i] && d[v[i]] == d[cur] + 1) + if(int t = dfs(v[i], std::min(a, flow[i]))) + { + flow[i] -= t, flow[i ^ 1] += t; + return t; + } + return 0; +} +int dinic() +{ + int ans = 0, t; + while(bfs()) + { + memcpy(work, first, sizeof(first[0]) * (T + 1)); + while(t = dfs(S, INF)) ans += t; + } + return ans; +} +void DFS(int cur) +{ + int i; + d[cur] = 1; + for(i = first[cur]; i != -1; i = next[i]) + if(flow[i] && !d[v[i]]) + DFS(v[i]); +} +void solve() +{ + int i, ans = dinic(), n = 0; + printf("%d\n", MAX - ans); + memset(d, 0, sizeof(d[0]) * (T + 1)); + DFS(S); + for(i = 0; i < M; i ++) + if(d[v[i << 1 | 1]] && !d[v[i << 1]]) + q[n ++] = id[i << 1]; + std::sort(q, q + n); + printf("%d", n); + for(i = 0; i < n; i ++) printf(" %d", q[i]); + printf("\n"); +} +int main() +{ + int t, tt; + scanf("%d", &t); + for(tt = 1; tt <= t; tt ++) + { + init(); + printf("Case %d: ", tt); + solve(); + } + return 0; +} diff --git a/HDOJ/3252_autoAC.cpp b/HDOJ/3252_autoAC.cpp new file mode 100644 index 0000000..295ea99 --- /dev/null +++ b/HDOJ/3252_autoAC.cpp @@ -0,0 +1,196 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAX=1005,INF=1<<30; +const string END="#CODE-END"; +int len; +map mymap; +map::iterator ite; +vector A,B; +int cnt; +int f[MAX][MAX]; +int ma[MAX],mb[MAX]; +vector a,b; +int Test; +void read(vector &t,vector &arr){ + string s; + while(getline(cin,s)){ + if(s==END) + break; + ite=mymap.find(s); + if(ite==mymap.end()) + mymap[s]=len++; + t.push_back(s); + arr.push_back(mymap[s]); + } + return ; +} +void createM(){ + int n1=(int)a.size()-1,n2=(int)b.size()-1; + memset(f,0,sizeof(f)); + for(int i=n1;i>=1;i--){ + for(int j=n2;j>=1;j--){ + if(a[i]==b[j]) + f[i][j]=f[i+1][j+1]+1; + else + f[i][j]=max(f[i+1][j],f[i][j+1]); + } + } + int L=f[1][1]; + cnt=f[1][1]; + int x = -1,c=0; + for(int i = 1; i<=n1; i++) + { + for(int j = 1; j<= n2; j++) + { + if(a[i] == b[j] && f[i][j] == L && j > x) + { + x = j; + L--; + ma[c]=i-1; + mb[c]=j-1; + x = j; + c++; + break; + } + } + } + return ; +} +struct DD{ + bool isM; + int b,e; +}; +DD DA[MAX*3],DB[MAX*3]; +void cut(){ + int front=0,rear=0; + int len=0; + for(int i=0;i<2*cnt;i++,len++){ + rear=ma[len]; + if(front>Test; + cin.ignore(); + while(Test--){ + cout<<"Case "< +#include +#include +#include +using namespace std; +int n,x[210],y[210],d[210],rx[210],ry[210]; +struct heap +{ + int t1,t2; + bool cmp(const int &u,const int &v) + { return t1*x[u]+t2*y[u]>t1*x[v]+t2*y[v]; } + int n,h[210],e[210]; + void del(int i) + { + e[h[i]]=0; + if (i==n) + { n--; return; } + h[i]=h[n--]; e[h[i]]=i; + down(i); up(i); + } + void build(void) + { + for(int i=(n>>1);i>=1;i--) + down(i); + } + void up(int i) + { + int t,j; + while(i>1) + { + j=(i>>1); + if (cmp(h[i],h[j])) + { + t=h[i]; h[i]=h[j]; h[j]=t; + e[h[i]]=i; e[h[j]]=j; + } + else break; + i=j; + } + } + void down(int i) + { + int t,j; + while((j=(i<<1))<=n) + { + if (j=1;i--) + { + l1=x[h1.h[1]]+y[h1.h[1]]-d[i]; + r1=x[h3.h[1]]+y[h3.h[1]]+d[i]; + l2=-x[h2.h[1]]+y[h2.h[1]]-d[i]; + r2=-x[h4.h[1]]+y[h4.h[1]]+d[i]; + if (i +#include +#include +using namespace std; +#define MAX 150105 +#define lch(i) ((i)<<1) +#define rch(i) ((i)<<1|1) +struct rec{ + __int64 x1,y1,x2,y2,v; +}; +struct segment{ + __int64 l,r,h,val; +}; +struct tree{ + int l,r,cnt,sum; + int mid() + { return (l+r)>>1; } +}; +typedef struct rec rec; +typedef struct segment segment; +typedef struct tree tree; +rec rr[MAX]; +segment ss[MAX]; +tree tt[MAX]; +__int64 pos[MAX]; +__int64 v[MAX]; +int N,M; +int cmp_rec(rec a ,rec b) +{ return a.v < b.v; } +int cmp_segment(segment a , segment b) +{ return a.h < b.h; } +void input() +{ + scanf("%d%d",&N,&M); + for(int i=1; i<=M; i++) scanf("%I64d",&v[i]); + for(int i=0; i>1; + if(pos[mid]==key) return mid; + else if(key < pos[mid]) high=mid-1; + else low=mid+1; + } + return -1; +} +void cal(int rt) +{ + if(tt[rt].cnt) + tt[rt].sum=pos[tt[rt].r+1]-pos[tt[rt].l]; + else if(tt[rt].l==tt[rt].r) + tt[rt].sum=0; + else + tt[rt].sum=tt[lch(rt)].sum + tt[rch(rt)].sum; +} +void updata(int l , int r , int val ,int rt) +{ + if(tt[rt].l==l && tt[rt].r==r) + { + tt[rt].cnt += val ; + cal(rt); + return ; + } + int mid=tt[rt].mid(); + if(r<=mid) + updata(l,r,val,lch(rt)); + else if(l>mid) + updata(l,r,val,rch(rt)); + else + { + updata(l,mid,val,lch(rt)); + updata(mid+1,r,val,rch(rt)); + } + cal(rt); +} +__int64 solve(int nn) +{ + int m=0; + for(int i=nn; i +#include +#include +#include +#include +using namespace std; +const int M=10010; +const int N=510; +char s[110]; +struct Line +{ + __int64 x1, y1, x2, y2; +} ll[N], pos; +int n, flag[M*2], ans; +void input(__int64 &a) +{ + scanf("%s", &s); + int i, j, len=strlen(s); + a = 0; + i = 0; + if(s[0]=='-') + i++; + for(; ili.y2) + swap(li.y1, li.y2); + if(li.y1<=0) + li.y1 = li.y1/10000; + else + li.y1 = li.y1/10000+1; + if(li.y2>=0) //... + li.y2 /= 10000; + else + li.y2 = li.y2/10000-1; + for(int j=li.y1; j<=li.y2; j++) + { + if(flag[j+M]!=i) + { + flag[j+M] = i; + ans++; + } + } + } + return; + } + if(!(li.x1<=i*10000 && i*10000<=li.x2) ) + return; + if((i*10000-li.x1)*(li.y2-li.y1)%(li.x2-li.x1)==0) + { + int j = (i*10000-li.x1)*(li.y2-li.y1)/(li.x2-li.x1)+li.y1; + if(j%10000==0) + { + j /= 10000; + if(flag[j+M]!=i) + { + flag[j+M] = i; + ans++; + } + } + } +} +int main() +{ + int i, j, cas, cas1; + scanf("%d", &cas); + for(cas1=1; cas1<=cas; cas1++) + { + scanf("%d", &n); + pos.x1 = M*M*10; + pos.x2 = -M*M*10; + for(i=0; i ll[i].x2) + { + swap(ll[i].x1, ll[i].x2); + swap(ll[i].y1, ll[i].y2); + } + if(ll[i].x1pos.x2) + pos.x2 = ll[i].x1; + if(ll[i].x2>pos.x2) + pos.x2 = ll[i].x2; + } + for(i=0; i +#include +#include +#include +using namespace std; +string str[17]={"0000","0001","0010","0011","0100","0101","0110","0111", +"1000","1001","1010","1011","1100","1101","1110","1111"}; +char map[8][500]; +string trans(string ch) +{ + string s=""; + for(int i=0;i<2;i++) + { + if(ch[i]>='A'&&ch[i]<='F') + s+=str[ch[i]-'A'+10]; + else + s+=str[ch[i]-'0']; + } + return s; +} +int main() +{ + string ch,str; + int t,n,i,j,k,p; + scanf("%d",&t); + for(int Case=1;Case<=t;Case++) + { + scanf("%d",&n); + int minx=10,maxn=-1; + p=0; + for(i=0;i>ch; + ch=trans(ch); + for(j=0;j<=7;j++) + { + if(ch[j]=='1') + map[j][p]='#'; + else map[j][p]=' '; + } + p++; + } + if(i!=n-1) + { + for(j=0;j<=7;j++) + map[j][p]=' '; + p++; + } + } + printf("Case %d:\n\n",Case); + bool flag=0,tag=0; + for(i=7;i>=0;i--) + { + for(j=0;j=k;i--) + { + for(j=0;j +#include +#include +using namespace std; +const int MaxN = 3005; +char s1[MaxN],s2[MaxN]; +typedef long long LL; +LL dp[2][MaxN]; +int main() +{ + int T,cas=0;scanf("%d",&T); + while(T--) + { + scanf("%s%s",s1,s2+1); + int n = strlen(s2+1), m = strlen(s1); + bool ok = 1; + for(int i = 1; i <= n; i++)if(s2[i]!='*')ok=0; + if(ok) + { + printf("Case %d: %d\n",++cas,m*(m+1)/2); + continue; + } + memset(dp, 0, sizeof(dp)); + for(int i = 0; i <= m; i++)dp[0][i]= 1; + ok = 1; + bool first = 1; + for(int i = 1; i <= n; i++) + { + int p = i&1; + int q = 1-p; + if(s2[i]=='*') + { + dp[p][0] = dp[q][0]; + if(first) + for(int j = 1; j <= m; j++) + dp[p][j] = dp[p][j-1]+dp[q][j]; + else + { + LL mx = dp[q][0]; + for(int j = 1; j <= m; j++) + { + mx = max(mx, dp[q][j]); + dp[p][j] = mx; + } + } + first = 0; + } + else if(s2[i]=='?') + { + dp[p][0] = 0; + for(int j = 1; j <= m; j++) + dp[p][j] = dp[q][j-1]; + } + else + { + dp[p][0] = 0; + for(int j = 1; j <= m; j++) + { + if(s1[j-1]==s2[i])dp[p][j] = dp[q][j-1]; + else dp[p][j] = 0; + } + } + } + LL ans = 0; + for(int i = 1; i <= m; i++) + ans += dp[n&1][i]; + printf("Case %d: %I64d\n",++cas,ans); + } + return 0; +} diff --git a/HDOJ/3260_autoAC.cpp b/HDOJ/3260_autoAC.cpp new file mode 100644 index 0000000..f4e9535 --- /dev/null +++ b/HDOJ/3260_autoAC.cpp @@ -0,0 +1,57 @@ +#include +#include +using namespace std; +#define inf (-((1<<30)-1)) +#define max(a,b) ((a)>(b)?(a):(b)) +char opt[105][1005]; +int value[105][1005]; +int dp[1005]; +int n,m,k; +void dfs(int x,int y,int v,int ki,int money,int pre) +{ + if(x==1&&y!=pre) + { + dp[y]=max(dp[y],dp[pre]+money); + return; + } + if(ki>=k) return; + if(y>=m) return; + money+=(opt[x][y]=='$'?value[x][y]:0); + int vi=(x!=1?(opt[x][y]!='$'?value[x][y]:0):0); + for(int i=-1;i<=1;++i) + { + int pos=x+v+vi+i; + if(pos<=1) + dfs(1,y+1,0,0,money,pre); + else + { + if(pos>n) pos=n; + dfs(pos,y+1,v+vi+i,ki+1,money,pre); + } + } +} +int main() +{ + char c; + for(; ~scanf("%d%d%d",&n,&m,&k);) + { + if(n+m+k==0) break; + for(int i=1; i<=n; ++i) + { + for(int j=1; j<=m; ++j) + { + for(;c=getchar();) + if(c=='v'||c=='$') break; + opt[i][j]=c; + scanf("%d",&value[i][j]); + } + } + dp[1]=0; + for(int i=2;i<=m;++i) dp[i]=inf; + for(int i=1;i +#include +#include +#include +#include +using namespace std; +const int MAXN=33; +struct rec +{ + int x,y,d; +}ans[MAXN*2]; +struct node +{ + int h,m,dat,num; +}a[MAXN*2]; +int n,m,k; +int map[MAXN][MAXN]; +bool b[MAXN][MAXN]; +bool cmp(node a,node b) +{ + if (a.hMax.d) + Max.x=i,Max.y=j,Max.d=map[i][j]; + if (Max.x && Max.y) + { + ans[a[h].num]=Max; + for (int i=Max.y;i<=Max.y+a[h].dat-1;++i) b[Max.x][i]=1; + return 1; + } + return 0; +} +bool GM(int h) +{ + rec Max; + Max.x=Max.y=Max.d=0; + for (int i=1;i<=n;++i) + for (int j=1;j<=m;++j) + if (!b[i][j] && Max.d +#include +#include +#include +#include +using namespace std; +typedef struct pnode +{ + double x,y,d; + pnode( double a, double b ) {x = a;y = b;} + pnode(){}; +}point; +point H[ 21 ]; +point C[ 21 ]; +point P0,Pn; +typedef struct lnode +{ + double x,y,dx,dy,d; + int id,hit,sign; + lnode( point a, point b ) {x = a.x;y = a.y;dx = b.x-a.x;dy = b.y-a.y;} + lnode(){}; +}line; +double dist( point a, point b ) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +double dist( point a, line l ) +{ + return fabs(l.dx*(a.y-l.y)-l.dy*(a.x-l.x))/sqrt(l.dx*l.dx+l.dy*l.dy); +} +double crossproduct( point a, point b, point c ) +{ + return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y); +} +bool cmp1( point a, point b ) +{ + if ( a.x == b.x ) return a.y < b.y; + else return a.x < b.x; +} +bool cmp2( point a, point b ) +{ + double cp = crossproduct( P0, a, b ); + if ( cp == 0 ) return a.d < b.d; + else return cp > 0; +} +double Graham( int N ) +{ + sort( C+0, C+N, cmp1 ); + P0 = C[0]; + for ( int i = 1 ; i < N ; ++ i ) + C[i].d = dist( P0, C[i] ); + sort( C+1, C+N, cmp2 ); + int top = 2; + for ( int i = 3 ; i < N ; ++ i ) { + while ( top > 0 && crossproduct( C[top-1], C[top], C[i] ) <= 0 ) -- top; + C[++ top] = C[i]; + } + C[++ top] = C[0]; + int L = 0,R = 1; + double D = 500.000; + do{ + while ( crossproduct( C[R], C[L], C[(L+1)%top] ) <= crossproduct( C[(R+1)%top], C[L], C[(L+1)%top] ) ) + R = (R+1)%top; + D = min( D, dist( C[R], line( C[L], C[(L+1)%top] ) ) ); + L = (L+1)%top; + }while ( L ); + return D; +} +bool l_cross_s( line b, line a ) +{ + double t1 = b.dx*(a.y-b.y)-b.dy*(a.x-b.x); + double t2 = b.dx*(a.y+a.dy-b.y)-b.dy*(a.x+a.dx-b.x); + return t1*t2 < 0; +} +bool s_cross_s( line a, line b ) +{ + double t1 = 0.0+a.dx*(b.y-a.y)-a.dy*(b.x-a.x); + double t2 = 0.0+a.dx*(b.y+b.dy-a.y)-a.dy*(b.x+b.dx-a.x); + double t3 = 0.0+b.dx*(a.y-b.y)-b.dy*(a.x-b.x); + double t4 = 0.0+b.dx*(a.y+a.dy-b.y)-b.dy*(a.x+a.dx-b.x); + return (t1*t2 < 0)&&(t3*t4 < 0); +} +bool on( point p, line l ) +{ + if ( l.dx*(p.y-l.y)-l.dy*(p.x-l.x) == 0 ) + if ( (p.x-l.x)*(p.x-l.x-l.dx) <= 0 ) + if ( (p.y-l.y)*(p.y-l.y-l.dy) <= 0 ) + return true; + return false; +} +bool in( point p, point* P, int n ) +{ + double d[4][2] = {-101,-103,-103,101,101,-103,101,103}; + for ( int t = 0 ; t < 4 ; ++ t ) { + line s1 = line( p, point( d[t][0], d[t][1] ) ); + int count = 0; + for ( int i = 0 ; i < n ; ++ i ) { + line s2 = line( P[i], P[i+1] ); + if ( on( p, s2 ) ) return true; + if ( s_cross_s( s1, s2 ) ) count ++; + if ( on( P[i], s1 ) && l_cross_s( s1, line( P[i+1], P[(i-1+n)%n] ) ) ) count ++; + } + if ( count%2 == 0 ) return false; + } + return true; +} +point crosspoint( line l, line m ) +{ + point a = point( m.x, m.y ); + point b = point( m.x+m.dx, m.y+m.dy ); + if ( m.dx*l.dy == m.dy*l.dx ) { + if ( dist( point( l.x, l.y ), a ) < dist( point( l.x, l.y ), b ) ) + return a; + else return b; + }else { + double a1 = -l.dy,b1 = l.dx,c1 = l.dx*l.y-l.dy*l.x; + double a2 = -m.dy,b2 = m.dx,c2 = m.dx*m.y-m.dy*m.x; + double x = (c1*b2-c2*b1)/(a1*b2-a2*b1); + double y = (c1*a2-c2*a1)/(b1*a2-b2*a1); + return point( x, y ); + } +} +double Calcul( int N ) +{ + H[N] = H[0]; + point X[ 21 ]; + double D = 0.0; + for ( int i = 0 ; i < N ; ++ i ) + for ( int j = i+1 ; j < N ; ++ j ) { + line l = line( H[i], H[j] ); + int S = 0; + for ( int k = 0 ; k < N ; ++ k ) { + line m = line( H[k], H[k+1] ); + if ( l_cross_s( l, m ) ) + X[S ++] = crosspoint( l, m ); + } + X[S ++] = H[i]; + X[S ++] = H[j]; + P0 = point( -101, -103 ); + for ( int k = 0 ; k < S ; ++ k ) + X[k].d = dist( P0, X[k] ); + sort( X, X+S, cmp2 ); + double sum = 0.0; + int fla = 0; + for ( int i = 1 ; i < S ; ++ i ) { + if ( in( point( (X[i-1].x+X[i].x)/2, (X[i-1].y+X[i].y)/2 ), H, N ) ) { + if ( fla ) sum += dist( X[i-1], X[i] ); + else sum = dist( X[i-1], X[i] ); + D = max( D, sum ); + fla = 1; + } + } + } + return D; +} +int main() +{ + int T,N,M; + while ( scanf("%d",&T) != EOF ) + while ( T -- ) { + scanf("%d",&N); + for ( int i = 0 ; i < N ; ++ i ) + scanf("%lf%lf",&H[i].x,&H[i].y); + scanf("%d",&M); + for ( int i = 0 ; i < M ; ++ i ) + scanf("%lf%lf",&C[i].x,&C[i].y); + double d = Graham( M ); + double D = Calcul( N ); + if ( d <= D ) printf("legal\n"); + else printf("illegal\n"); + } + return 0; +} diff --git a/HDOJ/3264_autoAC.cpp b/HDOJ/3264_autoAC.cpp new file mode 100644 index 0000000..8037222 --- /dev/null +++ b/HDOJ/3264_autoAC.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +using namespace std; +#define repf(i,a,b) for(int i=(a);i<=(b);i++) +typedef long long ll; +const int N = 21; +const double PI = acos(-1.0); +const double EPS = 1e-8; +int t, n; +struct Round { + double x, y; + double r; +} r[N], ori; +double dis(const Round &a, const Round &b) { + return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); +} +double insection_of_rounds(Round &a, Round &b) { + double d = dis(a, b); + if (d >= a.r + b.r) + return 0; + if (d <= fabs(a.r - b.r)) { + double r = a.r < b.r ? a.r : b.r; + return PI * r * r; + } + double ang1 = acos((a.r * a.r + d * d - b.r * b.r) / 2. / a.r / d); + double ang2 = acos((b.r * b.r + d * d - a.r * a.r) / 2. / b.r / d); + double ret = ang1 * a.r * a.r + ang2 * b.r * b.r - d * a.r * sin(ang1); + return ret; +} +bool check(Round& ori) { + repf (i, 0, n - 1) { + if (insection_of_rounds(ori, r[i]) * 2 < PI * r[i].r * r[i].r) + return false; + } + return true; +}; +double bin(double l, double r, Round& ori) { + double mid; + while (fabs(l - r) >= EPS) { + mid = (l + r) / 2; + ori.r = mid; + if (check(ori)) { + r = mid; + } else { + l = mid + EPS; + } + } + return mid; +} +int main() { + scanf("%d", &t); + while (t--) { + scanf("%d", &n); + repf (i, 0, n - 1) { + scanf("%lf%lf%lf", &r[i].x, &r[i].y, &r[i].r); + } + double ans = 1e10; + repf (i, 0, n - 1) { + ori.x = r[i].x; + ori.y = r[i].y; + double right = 0; + repf (j, 0, n - 1) { + right = max(right, dis(ori, r[j]) + r[j].r); + } + ans = min(ans, bin(0, right, ori)); + } + printf("%.4f\n", ans); + } + return 0; +} diff --git a/HDOJ/3265_autoAC.cpp b/HDOJ/3265_autoAC.cpp new file mode 100644 index 0000000..d97d0a3 --- /dev/null +++ b/HDOJ/3265_autoAC.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +using namespace std; +const int maxx=55555; +struct node +{ + __int64 sum,color; +}tree[maxx<<3]; +struct seg +{ + int x1,x2,y,color; + seg(int a,int b,int c,int d):x1(a),x2(b),y(c),color(d){} + bool operator < (const seg &t)const{ + return y < t.y; + } +}; +void pushUp(int no,int l,int r) +{ + if(tree[no].color) tree[no].sum=r-l+1; + else if(l==r) tree[no].sum=0; + else tree[no].sum=tree[no<<1].sum+tree[no<<1|1].sum; +} +void update(int x1,int x2,int color,int l,int r,int no) +{ + if(x1<=l&&r<=x2) + { + tree[no].color+=color; + pushUp(no,l,r); + return; + } + int m=(l+r)>>1; + if(x1<=m) update(x1,x2,color,l,m,no<<1); + if(x2>m) update(x1,x2,color,m+1,r,no<<1|1); + pushUp(no,l,r); +} +int main() +{ + int n,x1,x2,x3,x4,y1,y2,y3,y4,i; + while(cin>>n,n) + { + vector v; + for(i=1;i<=n;++i) + { + cin>>x1>>y1>>x2>>y2>>x3>>y3>>x4>>y4; + if(x1v[i].x1) + update(v[i].x1,v[i].x2-1,v[i].color,0,maxx,1); + ret+=tree[1].sum*(v[i+1].y-v[i].y); + } + printf("%I64d\n",ret); + } + return 0; +} diff --git a/HDOJ/3266_autoAC.cpp b/HDOJ/3266_autoAC.cpp new file mode 100644 index 0000000..d289ba9 --- /dev/null +++ b/HDOJ/3266_autoAC.cpp @@ -0,0 +1,117 @@ +#include +#include +#include +#include +#include +using namespace std; +const int mn=100100,M=379177,base=213; +int n,m; +#define hf(a) ((a)&0x7fffffff)%M +struct node { + node *nxt; + int k,len; +} *ha[M],pool[M]; +int pp; +node* find(int k1,int len) { + for(node *p=ha[hf(k1)];p;p=p->nxt) + if(k1==p->k && len==p->len)return p; + return 0; +} +void insert(int k,int len) { + int h=hf(k); + pool[pp].k=k; + pool[pp].len=len; + pool[pp].nxt = ha[h]; + ha[h]=&pool[pp++]; +} +char ts[mn]; +string a,b; +vector a1,b1,a2,b2; +int pw[mn]; +void getbit(string &str1,string &str2,vector &bit) +{ + int len1,len2; + len1=str1.size(); + len2=str2.size(); + bit.clear(); + int key=0; + memset(ha,0,sizeof(ha)); + pp=0; + for(int i=0;i &a,vector &b) +{ + int i,j,c=0,tmp; + i=a.size()-1; j=b.size()-1; + while(1) + { + if(i<0 && j<0)break; + if(i>=0)c+=a[i]; + if(j>=0)c-=b[j]; + if(c<0) { a[i]=2+c; c=-1; } + else { a[i]=c; c=0; } + i-=1; + j-=1; + } +} +int main() +{ + pw[0]=1; + for(int i=1;ia1.size()-al)printf("Hamlet\n"); + else printf("Laertes\n"); + } + else + { + bool f=1; + while(1) + { + if(bl>=b1.size())break; + if(b1[bl]!=a1[al]) + { + if(b1[bl]>a1[al])printf("Hamlet\n"); + else printf("Laertes\n"); + f=0; + break; + } + bl++; + al++; + } + if(f)printf("Equal\n"); + } + } + return 0; +} diff --git a/HDOJ/3267_autoAC.cpp b/HDOJ/3267_autoAC.cpp new file mode 100644 index 0000000..2b5caf2 --- /dev/null +++ b/HDOJ/3267_autoAC.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +using namespace std; +#define LL long long +int n, m; +int l[32], r[32]; +bool red[32], blue[32]; +int find(int idx[10], int x){ + if(idx[x]==-1) return x; + return idx[x]=find(idx, idx[x]); +} +void merge(int gra[10][10],int idx[10], int x, int y){ + int rx = find(idx, x); + int ry = find(idx, y); + if(rx==ry) return; + idx[rx] = ry; + for(int k=0;k=2){ + merge(gra, idx, i, j); + flag = true; + } + } + } + } + int cnt=0; + for(int i=0;i +#include +#include +#include +#include +using namespace std; +const int maxn = 30; +const int maxm = 900; +const int INF = 1000000; +vector > > edge; +int dist[maxn+10]; +bool inQue[maxn+10]; +int n; +int num[maxn]; +void spfa(int src){ + memset(dist,63,sizeof(dist)); + memset(inQue,0,sizeof(inQue)); + dist[src] = 0; + queue que; + que.push(src); + inQue[src] = 1; + while(!que.empty()) { + int u = que.front(); + que.pop(); + for(int i = 0; i < edge[u].size(); i++) + if(dist[u]+edge[u][i].second> ncase; + while(ncase--){ + scanf("%d",&n); + init(); + for(int i = 1; i <= n; i++){ + int a,b; + scanf("%d%d",&a,&b); + num[a] = b; + edge[0].push_back(make_pair(a,b-1)); + } + for(int i = 1; i <= n; i++){ + for(int j = i+1; j <= n; j++){ + if(num[i]==num[j]){ + edge[i].push_back(make_pair(j,0)); + edge[j].push_back(make_pair(i,0)); + } + } + } + int m; + scanf("%d",&m); + while(m--){ + int a,b,c; + scanf("%d%d%d",&a,&b,&c); + edge[a].push_back(make_pair(b,c)); + } + spfa(0); + int cnt = 0; + for(int i=1;i<=n;i++){ + bool flag=0; + for(int j=1;j<=n;j++){ + if(i==j) continue; + for(int k=1;k<=n;k++){ + if(k!=i&&k!=j&&dist[i]==dist[j]+dist[k]){ + cnt++; + flag=1; + break; + } + } + if(flag) break; + } + } + for(int i = 1; i <= n; i++){ + cout< +#include +#include +#include +using namespace std; +#define N 32 +#define cls(a) memset(a, 0, sizeof(a)) +#define cls1(a,i,j) memset(a+i, 1, (j-i+1)*sizeof(bool)) +#define cls0(a, i) memset(a, 0, i*sizeof(bool)) +struct computer{ + bool able[1005]; + int pcent; +}cpt[N]; +bool isSver[N]; +int Sver[N]; +int Clnt[N]; +int rate[N][N]; +int main() +{ + int d, n, t, k, s, i, j, l, st, ed, m, c; + scanf("%d", &d); + while(d--) + { + cls(isSver); + cls(Clnt); + cls(Sver); + cls(cpt); + cls(rate); + scanf("%d%d", &n, &t); + scanf("%d%d", &s, &k); + for(i=0; i t) continue; + if(ed > t) ed = t; + for(l=st; l= k) + { + isSver[Clnt[j]] = 1; + Sver[s++] = Clnt[j]; + for(c--, l=j; l=k ? 100 : (cpt[i].pcent*100/k)); + } + } + return 0; +} diff --git a/HDOJ/3270_autoAC.cpp b/HDOJ/3270_autoAC.cpp new file mode 100644 index 0000000..6a3bea9 --- /dev/null +++ b/HDOJ/3270_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +char str[100]; +long long gcd(long long x,long long y) +{ + return y==0?x:gcd(y,x%y); +} +long long Ex_Euclid(long long a,long long b,long long &x,long long &y) +{ + long long ans,t; + if (b==0) + { + x=1; + y=0; + ans=0; + return ans; + } + ans=Ex_Euclid(b,a%b,x,y); + t=x; + x=y; + y=t-(a/b)*y; + return ans; +} +int main() +{ + int i,j,n; + long long A,B,C,D,x,y,k,t; + while(scanf("%s",str)!=EOF) + { + A=0; + for (i=0;i=0) + { + printf("Yes.\n\n"); + continue; + } + y=y*C/D; + t=A/D; + y=(y%t+t)%t; + k=(C-B*y)/A; + if (k>=0) + { + printf("Yes.\n\n"); + continue; + } + printf("No.\n\n"); + } + return 0; +} diff --git a/HDOJ/3271_autoAC.cpp b/HDOJ/3271_autoAC.cpp new file mode 100644 index 0000000..74022e0 --- /dev/null +++ b/HDOJ/3271_autoAC.cpp @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include +#define N 30 +#define inf 1<<29 +#define MOD 2007 +#define LL long long +using namespace std; +int dp[32][305]; +void Init(int b,int m){ + memset(dp,0,sizeof(dp)); + dp[0][0]=1; + for(int i=1;i<32;i++) + for(int j=0;j<=m;j++) + for(int k=0;k=0;j++) + sum+=dp[i-1][m-tot-j]; + tot+=bit[i]; + if(tot>m) break; + } + if(tot==m) sum++; + return sum; +} +int main(){ + int cas=0,kind,x,y,b,m,k; + while(scanf("%d%d%d%d%d",&kind,&x,&y,&b,&m)!=EOF){ + Init(b,m); + if(x>y) swap(x,y); + printf("Case %d:\n",++cas); + int cnt=clac(y,b,m)-clac(x-1,b,m); + if(kind==1){ + printf("%d\n",cnt); + continue; + } + scanf("%d",&k); + if(k>cnt){ + puts("Could not find the Number!"); + continue; + } + int low=x,high=y,mid; + while(low +#include +#include +#include +#include +using namespace std; +#define repf(i,a,b) for(int i=(a);i<=(b);i++) +typedef long long ll; +const int N = 0; +struct Point { + double x; + double y; +} h, o, p[3]; +double dis(const Point& a, const Point& b) { + return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); +} +double calc(int a, int b) { + double ret = dis(h, p[a]) + dis(p[a], p[b]) + dis(p[b], h); + double ha, ab, bh; + bool cx = 0, cy = 0; + if (h.x * p[a].x <= 0 || p[a].x * p[b].x <= 0 || p[b].x * h.x <= 0) + cx = 1; + if (h.y * p[a].y <= 0 || p[a].y * p[b].y <= 0 || p[b].y * h.y <= 0) + cy = 1; + if (cx == 0 && cy == 0) { + Point t1, t2; + t1.x = h.x; + t1.y = -h.y; + t2.x = -p[a].x; + t2.y = p[a].y; + ha = ret - dis(h, p[a]) + dis(t1, t2); + t1.x = p[b].x; + t1.y = -p[b].y; + t2.x = -p[a].x; + t2.y = p[a].y; + ab = ret - dis(p[a], p[b]) + dis(t1, t2); + t1.x = p[b].x; + t1.y = -p[b].y; + t2.x = -h.x; + t2.y = h.y; + bh = ret - dis(h, p[b]) + dis(t1, t2); + double ans = min(ha, min(ab, bh)); + t1.x = p[a].x; + t1.y = -p[a].y; + t2.x = -p[a].x; + t2.y = p[a].y; + ans = min(ans, ret - dis(p[a], h) + dis(t1, h) - dis(p[a], p[b]) + dis(t2, p[b])); + t1.x = h.x; + t1.y = -h.y; + t2.x = -h.x; + t2.y = h.y; + ans = min(ans, ret - dis(p[a], h) + dis(p[a], t1) - dis(h, p[b]) + dis(t2, p[b])); + t1.x = p[a].x; + t1.y = -p[a].y; + t2.x = -p[a].x; + t2.y = p[a].y; + ans = min(ans, ret - dis(p[a], p[b]) + dis(t1, p[b]) - dis(p[a], h) + dis(t2, h)); + t1.x = p[b].x; + t1.y = -p[b].y; + t2.x = -p[b].x; + t2.y = p[b].y; + ans = min(ans, ret - dis(p[a], p[b]) + dis(t1, p[a]) - dis(p[b], h) + dis(t2, h)); + t1.x = h.x; + t1.y = -h.y; + t2.x = -h.x; + t2.y = h.y; + ans = min(ans, ret - dis(p[b], h) + dis(p[b], t1) - dis(h, p[a]) + dis(t2, p[a])); + t1.x = p[b].x; + t1.y = -p[b].y; + t2.x = -p[b].x; + t2.y = p[b].y; + ans = min(ans, ret - dis(h, p[b]) + dis(t1, h) - dis(p[b], p[a]) + dis(t2, p[a])); + ret = ans; + } else if (cx == 1 && cy == 0) { + Point tmp; + tmp.x = p[a].x; + tmp.y = -p[a].y; + ha = ret - dis(h, p[a]) + dis(h, tmp); + ab = ret - dis(p[a], p[b]) + dis(tmp, p[b]); + tmp.x = p[b].x; + tmp.y = -p[b].y; + bh = ret - dis(h, p[b]) + dis(h, tmp); + ret = min(ha, min(ab, bh)); + } else if (cx == 0 && cy == 1) { + Point tmp; + tmp.x = -p[a].x; + tmp.y = p[a].y; + ha = ret - dis(h, p[a]) + dis(h, tmp); + ab = ret - dis(p[a], p[b]) + dis(tmp, p[b]); + tmp.x = -p[b].x; + tmp.y = p[b].y; + bh = ret - dis(h, p[b]) + dis(h, tmp); + ret = min(ha, min(ab, bh)); + } + return ret; +} +int main() { + o.x = 0; + o.y = 0; + int t; + cin >> t; + while (cin >> p[0].x >> p[0].y >> p[1].x >> p[1].y >> h.x >> h.y) { + printf("%.2f\n", calc(0, 1)); + } + return 0; +} diff --git a/HDOJ/3274_autoAC.cpp b/HDOJ/3274_autoAC.cpp new file mode 100644 index 0000000..666b115 --- /dev/null +++ b/HDOJ/3274_autoAC.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=2001; +int n,m,root,sum,NE=0,vis[maxn],head[maxn]; +struct node +{ + int u,v,w,next; +} Edge[maxn]; +void addEdge(int u,int v,int w) +{ + Edge[NE].u=u,Edge[NE].v=v,Edge[NE].w=w,Edge[NE].next=head[u]; + head[u]=NE++; +} +void dfs(int u,int fa) +{ + int i,j; + for(i=head[u];i!=-1;i=Edge[i].next) + { + int v=Edge[i].v; + if(v==fa)continue; + dfs(v,u); + if(vis[v]) + { + sum+=Edge[i].w; + vis[u]=1; + } + } +} +int main() +{ + while(scanf("%d%d",&n,&m)!=EOF) + { + int i,j,a,b,c; + sum=NE=0; + memset(vis,0,sizeof(vis)); + memset(head,-1,sizeof(head)); + for(i=1; i<=m; i++) + { + scanf("%d",&root); + vis[root]=1; + } + for(i=1; i +#include +using namespace std; +struct node{ + int num; + int flag; + int l; + int r; + int len; +}p[100005*6]; +int n,k,nima,cao; +char a[100005]; +void build(int l,int r,int n) +{ + p[n].l=l; + p[n].r=r; + p[n].len=r-l+1; + p[n].flag=0; + if(l==r) + { + if(a[l]=='1') + p[n].num=0; + else + p[n].num=1; + } + else + { + int mid=(l+r)/2; + build(l,mid,n*2); + build(mid+1,r,n*2+1); + p[n].num=p[n*2].num+p[n*2+1].num; + } +} +void pushdown(int n) +{ + p[n].flag=0; + p[n*2].flag^=1; + p[n*2+1].flag^=1; + p[n*2].num=p[n*2].len-p[n*2].num; + p[n*2+1].num=p[n*2+1].len-p[n*2+1].num; +} +void update(int x,int y,int n) +{ + if(x==p[n].l&&y==p[n].r) + { + p[n].flag^=1; + p[n].num=p[n].len-p[n].num; + } + else + { + int mid=(p[n].l+p[n].r)/2; + if(x>mid) + update(x,y,n*2+1); + else if(y<=mid) + update(x,y,n*2); + else + { + update(x,mid,n*2); + update(mid+1,y,n*2+1); + } + } +} +void insert(int x,int n) +{ + if(nima) + return ; + if(p[n].flag==1) + pushdown(n); + if(p[n].l==p[n].r) + { + if(p[n].num==1) + { + nima=p[n].l; + if(p[n].l+k-1<=cao) + update(p[n].l,p[n].l+k-1,1); + } + } + else + { + int mid=(p[n].l+p[n].r)/2; + if(x>mid) + insert(x,n*2+1); + else + { + insert(x,n*2); + insert(mid+1,n*2+1); + } + } +} +int main() +{ + int temp,t; + while(scanf("%d%d",&n,&k)!=EOF&&(n!=0||k!=0)) + { + cao=n; + temp=0; + t=0; + getchar(); + scanf("%s",a+1); + build(1,n,1); + if(p[1].num==0) + { + printf("0\n"); + continue; + } + if(k==0) + { + printf("-1\n"); + continue; + } + while(1) + { + nima=0; + insert(temp+1,1); + temp=nima; + if(nima==0) + break; + if(n-temp+1 +using namespace std; +#define N 50005 +#define esp 1e-5 +#define inf -10000000001 +double a[N],sum[N]; +double L[N],R[N]; +int q[N]; +int n,x,y; +int head,tail; +bool find(double ave){ + sum[0]=0; + for(int i=1;i<=n;i++) + sum[i]=sum[i-1]+a[i]-ave; + head=tail=0; + L[x-1]=inf; + for(int i=x;i<=n;i++){ + int p=i-x; + while(headq[head]) + head++; + L[i]=max(L[i-1],sum[i]-sum[q[head]]); + } + sum[n+1]=0; + for(int i=n;i>0;i--) + sum[i]=sum[i+1]+a[i]-ave; + head=tail=0; + R[n-x+2]=inf; + for(int i=n-x+1;i>0;i--){ + int p=i+x; + while(head=0) + return true; + return false; +} +int main(){ + int k=1; + while(~scanf("%d%d%d",&n,&x,&y)){ + for(int i=1;i<=n;i++) + scanf("%lf",&a[i]); + double f=1.0,l=200000.0,ret; + while(l-f>=esp){ + double mid=(f+l)/2; + if(find(mid)){ + f=mid; + ret=mid; + } + else + l=mid; + } + printf("Case %d: %.3lf\n",k++,ret); + } +} diff --git a/HDOJ/3277_autoAC.cpp b/HDOJ/3277_autoAC.cpp new file mode 100644 index 0000000..b920c8d --- /dev/null +++ b/HDOJ/3277_autoAC.cpp @@ -0,0 +1,230 @@ +#include +#include +#include +#include +#define clr(x)memset(x,0,sizeof(x)) +#define min(a,b)(a)<(b)?(a):(b) +const int INF=INT_MAX; +const int maxn=800; +const int maxm=1000000; +struct node +{ + int from,to,next,c; +}e[maxm]; +int tot; +int head[maxn]; +void add(int s,int u,int f1,int f2) +{ + e[tot].from=s; + e[tot].to=u; + e[tot].c=f1; + e[tot].next=head[s]; + head[s]=tot++; + e[tot].from=u; + e[tot].to=s; + e[tot].c=f2; + e[tot].next=head[u]; + head[u]=tot++; +} +int q[maxn]; +int cnt[maxn]; +int d[maxn]; +int low[maxn]; +int cur[maxn]; +int maxflow(int s,int t,int n) +{ + int *front=q,*rear=q; + for(int i=0;i0) + { + d[e[i].to]=d[v]+1; + cnt[n]--; + cnt[d[e[i].to]]++; + *rear++=e[i].to; + } + } + } + int flow=0, u=s, top=0; + low[0]=INF; + for(int i=0;i0&&d[u]==d[e[i].to]+1) + { + low[top+1]=min(low[top],e[i].c); + q[++top]=i; + u=e[i].to; + break; + } + } + if(i!=-1) + { + if(u==t) + { + int minf=low[top]; + for(int p=1,i;p<=top;++p) + { + i=q[p]; + e[i].c-=minf; + e[i^1].c+=minf; + } + flow+=minf; + u=s; + low[0]=INF; + top=0; + } + } + else + { + int old_du=d[u]; + cnt[old_du]--; + d[u]=n-1; + for(int i=head[u];i!=-1;i=e[i].next) + if(e[i].c>0&&d[u]>d[e[i].to]) + d[u]=d[e[i].to]; + cnt[++d[u]]++; + if(d[u]>1; + if(ok(mid,s,t,n)){ + res = mid; + l = mid+1; + } + else r = mid-1; + } + printf("%d\n",res); + } + return 0; +} diff --git a/HDOJ/3278_autoAC.cpp b/HDOJ/3278_autoAC.cpp new file mode 100644 index 0000000..e6e7cf4 --- /dev/null +++ b/HDOJ/3278_autoAC.cpp @@ -0,0 +1,118 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define N 10 +using namespace std; +char s[5][7],str[25]; +char v[1<<24]; +queue que; +int inline row_op(int r,int n,int op) +{ + int tmp[6]; + for(int i=0;i<6;i++){ + tmp[i]=n&(1<<(r*6+i)); + n-=tmp[i]; + } + if(op){ + tmp[0]<<=5; + for(int i=1;i<6;i++){ + tmp[i]>>=1; + } + }else{ + for(int i=0;i<5;i++){ + tmp[i]<<=1; + } + tmp[5]>>=5; + } + n+=tmp[0]+tmp[1]+tmp[2]+tmp[3]+tmp[4]+tmp[5]; + return n; +} +int inline col_op(int c,int n,int op) +{ + int tmp[4]; + for(int i=0;i<4;i++){ + tmp[i]=n&(1<<(i*6+c)); + n-=tmp[i]; + } + if(op){ + tmp[0]<<=18; + tmp[1]>>=6; + tmp[2]>>=6; + tmp[3]>>=6; + }else{ + tmp[0]<<=6; + tmp[1]<<=6; + tmp[2]<<=6; + tmp[3]>>=18; + } + n+=tmp[0]+tmp[1]+tmp[2]+tmp[3]; + return n; +} +void countMoves() +{ + int cnt=0; + while(!que.empty()) que.pop(); + memset(v,-1,sizeof(v)); + que.push(124800); + v[124800]=0; + while(!que.empty()){ + int t=que.front(); + que.pop(); + for(int i=0;i<4;i++){ + int tmp=row_op(i,t,1); + if(v[tmp]==-1){ + que.push(tmp); + v[tmp]=v[t]+1; + } + tmp=row_op(i,t,0); + if(v[tmp]==-1){ + que.push(tmp); + v[tmp]=v[t]+1; + } + } + for(int j=0;j<6;j++){ + int tmp=col_op(j,t,1); + if(v[tmp]==-1){ + que.push(tmp); + v[tmp]=v[t]+1; + } + tmp=col_op(j,t,0); + if(v[tmp]==-1){ + que.push(tmp); + v[tmp]=v[t]+1; + } + } + } + return; +} +int main() +{ + int T,cas=1; + int b,w,g; + cin >> T; + countMoves(); + while(T--){ + b=w=g=0; + for(int i=0;i<4;i++){ + scanf("%s",s[i]); + for(int j=0;j<6;j++){ + if(s[i][j]=='B'){ + b+=(1<<(i*6+j)); + }else if(s[i][j]=='W'){ + w+=(1<<(i*6+j)); + }else{ + g+=(1<<(i*6+j)); + } + } + } + int cnt = min(v[b],min(v[w],v[g])); + cout << "Case " << cas << ": " << cnt << endl; + cas++; + } + return 0; +} diff --git a/HDOJ/3279_autoAC.cpp b/HDOJ/3279_autoAC.cpp new file mode 100644 index 0000000..a9f6658 --- /dev/null +++ b/HDOJ/3279_autoAC.cpp @@ -0,0 +1,21 @@ +#include +#include +using namespace std; +int main() +{ + int i,j,n,t,b; + int a[11]; + while(scanf("%d",&t)!=EOF) + { + int k=1; + while(t--) + { + scanf("%d",&b); + for(i=0;i<10;i++) + scanf("%d",&a[i]); + sort(a,a+10); + printf("%d %d\n",k++,a[7]); + } + } + return 0; +} diff --git a/HDOJ/3280_autoAC.cpp b/HDOJ/3280_autoAC.cpp new file mode 100644 index 0000000..c0fc0bd --- /dev/null +++ b/HDOJ/3280_autoAC.cpp @@ -0,0 +1,43 @@ +#include +int main() +{ + int i,j,n,t,b; + int a[10005]; + while(scanf("%d",&t)!=EOF) + { + int k=1; + while(t--) + { + scanf("%d %d",&b,&n); + for(i=0;isum) + { + flag=1; + break; + } + else if(j==n-1) + { + flag=1; + break; + } + } + if(flag==0) + break; + } + printf("%d %d\n",k++,sum); + } + } + return 0; +} diff --git a/HDOJ/3281_autoAC.cpp b/HDOJ/3281_autoAC.cpp new file mode 100644 index 0000000..446a633 --- /dev/null +++ b/HDOJ/3281_autoAC.cpp @@ -0,0 +1,29 @@ +#include +#include +#include +#include +#include +using namespace std; +int f[55][1005]; +void init(){ + for(int i = 1; i < 1001; i ++) + f[1][i] = i; + for(int i = 2; i < 51; i ++){ + f[i][1] = 1; + for(int j = 2; j < 1001; j ++){ + f[i][j] = f[i][j - 1] + 1;; + for(int k = 2; k < j; k ++){ + f[i][j] = min(f[i][j], max(f[i - 1][k - 1], f[i][j - k]) + 1); + } + } + } +} +int main(){ + int t, T, n, m; + init(); + scanf("%d", &T); + while(T --){ + scanf("%d%d%d", &t, &n, &m); + cout< +#include +#include +#include +using namespace std; +void run() +{ + int n,m; + scanf("%d%d",&n,&m); + int i,num[10001]; + int ans[10001]={0}; + int u=2; + printf("%d %d\n",n,(m+1)/2); + scanf("%d",&num[1]); + ans[1]=num[1]; + for(i=2;i<=m;i++) + { + int tmp,j,k; + scanf("%d",&tmp); + if(tmp<=num[1]) + { + for(k=i-1;k>=1;k--) + { + num[k+1]=num[k]; + } + num[1]=tmp; + } + else if(tmp>=num[i-1]) + {num[i]=tmp;} + else + { + bool f=false; + for(j=i-1;j>=1;j--) + { + if(tmp>=num[j-1] && tmp<=num[j]) + { + f=true; + int k; + { + for(k=i-1;k>=j;k--) + { + num[k+1]=num[k]; + } + num[j]=tmp; + } + } + if(f==true) break; + } + } + if(i%2==1) + { + ans[u++]=num[(i+1)/2]; + } + } + for(i=1;i>total; + for(int now=1;now<=total;now++) run(); + return 0; +} diff --git a/HDOJ/3283_autoAC.cpp b/HDOJ/3283_autoAC.cpp new file mode 100644 index 0000000..ac01d8c --- /dev/null +++ b/HDOJ/3283_autoAC.cpp @@ -0,0 +1,20 @@ +#include +#include +#include +#include +using namespace std; +char a[100]; +int main() +{ + int t,i,len,n; + scanf("%d",&t); + for(i=1;i<=t;i++) + { + scanf("%d %s",&n,a); + len=strlen(a); + if (next_permutation(a,a+len)) printf("%d %s\n",i,a); + else + printf("%d BIGGEST\n",i); + } + return 0; +} diff --git a/HDOJ/3284_autoAC.cpp b/HDOJ/3284_autoAC.cpp new file mode 100644 index 0000000..13cb816 --- /dev/null +++ b/HDOJ/3284_autoAC.cpp @@ -0,0 +1,24 @@ +#include +int dp[102][102][2]; +int main() +{ + int z,ca,n,k; + scanf("%d",&z); + dp[1][0][0] = dp[1][0][1] = 1; + for(int i=2;i<=100;i++) + { + dp[i][0][0] = dp[i-1][0][0] + dp[i-1][0][1]; + dp[i][0][1] = dp[i-1][0][0]; + for(int j=1;j +#include +#define eps 1e-8 +#define zero(x) (((x)>0?(x):-(x))0?1:-1):(ret>0?1:-1); +} +void _graham(int n,point* p,int& s,point* ch){ + int i,k=0; + for (p1=p2=p[0],i=1;ieps||(zero(p1.y-p[i].y)&&p1.x>p[i].x)) + p1=p[k=i]; + p2.x/=n,p2.y/=n; + p[k]=p[0],p[0]=p1; + qsort(p+1,n-1,sizeof(point),graham_cp); + for (ch[0]=p[0],ch[1]=p[1],ch[2]=p[2],s=i=3;i2&&xmult(ch[s-2],p[i],ch[s-1])<-eps;s--); +} +int graham(int n,point* p,point* convex,int maxsize=1,int dir=1){ + point* temp=new point[n]; + int s,i; + _graham(n,p,s,temp); + for (convex[0]=temp[0],n=1,i=(dir?1:(s-1));dir?(imaxy)||(a[i].y==maxy&&a[i].xmaxy)||(b[i].y==maxy&&b[i].x +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define LL long long +#define pi acos(-1) +#define MAX INT_MAX +#define MIN INT_MIN +#define eps 1e-6 +#define N 55 +struct point{ + int x,y; +}p[N]; +int n; +int ans[10010][3]; +int tot; +void gao(int y){ + int i,j; + double m[5]; + int cnt=0; + for(i=1;i<=n;i++){ + if(p[i].y==y && p[i-1].y==y)return ; + if(p[i].y==y)m[cnt++]=(double)p[i].x; + if(p[i-1].y==y)m[cnt++]=(double)p[i-1].x; + if((p[i-1].yy) || (p[i-1].y>y && p[i].yt)return ; + ans[tot][0]=y; + ans[tot][1]=s; + ans[tot][2]=t; + tot++; +} +int main(){ + int t; + scanf("%d",&t); + while(t--){ + int ca; + scanf("%d%d",&ca,&n); + int i,j; + int minm=MAX; + int maxm=MIN; + for(i=1;i<=n;i++){ + scanf("%d%d",&p[i].x,&p[i].y); + minm=min(minm,p[i].y); + maxm=max(maxm,p[i].y); + } + p[0].x=p[n].x; + p[0].y=p[n].y; + tot=0; + for(i=maxm-1;i>=minm+1;i--){ + gao(i); + } + printf("%d %d\n",ca,tot); + for(i=0;i +#include +#include +#include +#include +#include +#include +using namespace std; +struct node{ + int num; + int cnt; + string str; +}p[830000], tmp, t; +int p7[8] = {0, 1, 7, 49, 343, 2401, 16807, 117649}; +int tnum[8]; +int num = 1 * p7[1] + 2 * p7[2] + 3 * p7[3] + 4 * p7[4] + 5 * p7[5] + 6 * p7[6] ; +int tu[8][8] ={ + 0, 1, 2, 3, 4, 5, 6, 7, + 0, 0, 1, 0, 0, 0, 6, 0, + 0, 1, 0, 3, 0, 0, 0, 7, + 0, 0, 2, 0, 4, 0, 0, 0, + 0, 0, 0, 3, 0, 5, 0, 0, + 0, 0, 0, 0, 4, 0, 6, 7, + 0, 1, 0, 0, 0, 5, 0, 0, + 0, 0, 2, 0, 0, 5, 0, 0, +}; +deque q; +int maxx = 0; +void init(){ + p[num].num = num; + p[num].cnt = 0; + q.push_back(p[num]); + while(!q.empty()){ + tmp = q.front(); q.pop_front(); + int k; + for(int i = 1, n = tmp.num;i < 8; i ++){ + tnum[i] = n % 7; + if(tnum[i] == 0) k = i; + n /= 7; + } + for(int j = 1; j < 8; j ++) + if(tu[k][j]){ + t.cnt = tmp.cnt + 1; + t.num = tmp.num - p7[j] * tnum[j] + p7[k] * tnum[j]; + if(p[t.num].num == 0) { + t.str = tmp.str + (char)(tnum[j] + 'A' - 1); + q.push_back(t); + p[t.num] = t; + } + } + } +} +int main(){ + init(); + string s; + int T, t; + scanf("%d", &T); + while(T --){ + scanf("%d", &t); + cin>>s; + int num = 0; + for(int i = 0; i < s.length(); i ++){ + num += p7[i + 1] * (s[i] - 'A'+ 1); + } + s = p[num].str; + string str(s.rbegin(), s.rend()); + if(p[num].cnt == 0 && num != 114381) cout< +#include +#include +#define MAXN 10010 +using namespace std; +struct node +{ + int pri,num; + bool friend operator<(const node a,const node b) + { + if(a.pri!=b.pri) + return a.pri>b.pri; + return a.num>b.num; + } +}; +int hash1[MAXN],h; +priority_queue Q[MAXN]; +int main() +{ + int n,x,y,r,cc; + char str[10]; + while(scanf("%d",&n)==1) + { + h=0; + cc=1; + for(int i=0;i<=n;i++) + while(!Q[i].empty()) + Q[i].pop(); + memset(hash1,-1,sizeof(hash1)); + while(n--) + { + node temp; + scanf("%s",str); + if(str[0]=='R') + { + scanf("%d %d",&x,&y); + if(hash1[x]==-1) + hash1[x]=h++; + temp.num=cc++; + temp.pri=y; + Q[hash1[x]].push(temp); + } + else { + scanf("%d",&r); + if(hash1[r]==-1) + hash1[r]==h++; + if(Q[hash1[r]].empty()) + printf("No one fits!\n"); + else + { + temp = Q[hash1[r]].top(); + printf("%s gets Num %d: %d %d!\n",str,temp.num,r,temp.pri); + Q[hash1[r]].pop(); + } + } + } + } + return 0; +} diff --git a/HDOJ/3289_autoAC.cpp b/HDOJ/3289_autoAC.cpp new file mode 100644 index 0000000..7bfc02e --- /dev/null +++ b/HDOJ/3289_autoAC.cpp @@ -0,0 +1,131 @@ +#include +#include +#include +#include +using namespace std; +const int MAXN = 100010; +int spos[MAXN],epos[MAXN],sum[MAXN],w[MAXN]; +int n,f[MAXN],index; +bool vis[MAXN]; +struct edge +{ + int u,v,w; + edge(int a=0,int b=0,int c=0):u(a),v(b),w(c){} + bool friend operator<(const edge a,const edge b) + { + return a.w Q; +vector g[MAXN]; +void init() +{ + for(int i=0;i<=n;i++) + { + f[i]=i; + w[i]=sum[i]=0; + g[i].clear(); + } +} +int find(int x) +{ + if(x==f[x]) + return f[x]; + f[x]=find(f[x]); + return f[x]; +} +void Union(int x,int y) +{ + int a=find(x); + int b=find(y); + if(a==b) return ; + f[a]=b; + g[x].push_back(y); + g[y].push_back(x); +} +void Kruskal() +{ + while(!Q.empty()) + { + Union(Q.top().u,Q.top().v); + Q.pop(); + } +} +int lowbit(int x) +{ + return x&(-x); +} +void modify(int x,int add) +{ + while(x<=n) + { + sum[x]+=add; + x+=lowbit(x); + } +} +int get_sum(int x) +{ + int ret=0; + while(x!=0) + { + ret+=sum[x]; + x-=lowbit(x); + } + return ret; +} +void dfs(int u) +{ + spos[u]=index; + vis[u]=true; + for(int i=0;i +#include +#include +#define MAXN 20000+10 +using namespace std; +vector g[MAXN]; +int n,v[MAXN],in[MAXN],out[MAXN]; +int dfs(int cnt) +{ + if(out[cnt]==0) + return cnt; + vector ss; + for(int i=0;i +#include +using namespace std; +const double eps=1e-9; +const double maxl=1e10; +const double pi=3.1415926535897932384626433832795; +const int maxv=20; +template +T Max(T a,T b){return a>b?a:b;} +template +T Min(T a,T b){return aeps) return 1;if (a<-eps) return -1;return 0;} +struct Point +{ +double x,y; +Point(){}; +Point(double dx,double dy){x=dx;y=dy;} +inline int init(){ return scanf("%lf%lf",&x,&y); } +}; +double dis(Point a,Point b); +Point operator -(Point a,Point b){Point c;c.x=a.x-b.x;c.y=a.y-b.y;return c;} +Point operator +(Point a,Point b){Point c;c.x=a.x+b.x;c.y=a.y+b.y;return c;} +Point operator *(Point a,double d){Point c;c.x=a.x*d;c.y=a.y*d;return c;} +Point operator *(double d,Point a){Point c;c.x=a.x*d;c.y=a.y*d;return c;} +Point operator /(Point a,double d){Point c;c.x=a.x/d;c.y=a.y/d;return c;} +double operator *(Point a,Point b){return a.x*b.x+a.y*b.y;} +int operator ==(Point a,Point b){return dis(a,b)=eps;} +bool operator < (const Point &l, const Point &r){return sgn(l.y-r.y)<0 ||( sgn(l.y-r.y)==0 && sgn(l.x-r.x)<0 );} +double dis(Point a,Point b){a=a-b;return sqrt(sqr(a.x)+sqr(a.y));} +double crossmuti(Point a,Point b){return a.x*b.y-a.y*b.x;} +struct LineSegment +{ +Point pt1,pt2; +LineSegment(){}; +LineSegment(Point p1,Point p2){pt1=p1;pt2=p2;} +}; +struct Polygon +{ +Point vertex[maxv]; +int numv; +Polygon(){numv=0;} +Polygon(Point *s,int num){numv=num;memcpy(vertex,s,num*sizeof(Point));} +Point &operator [](int k){return vertex[k];} +}; +struct Line +{ +double a,b,c; +Line(){}; +Line(double p,double q,double r){a=p;b=q;c=r;} +Line(Point p,Point q) +{ + a=q.y-p.y; + b=p.x-q.x; + c=p.y*q.x-p.x*q.y; + double one=sqrt(sqr(a)+sqr(b)); + if (one>0) {a/=one;b/=one;c/=one;} +} +Line(LineSegment l) +{ + Line ls(l.pt1,l.pt2); + a=ls.a;b=ls.b;c=ls.c; +} +double func(Point &p){return a*p.x+b*p.y+c;} +}; +int ondiffside(Line l,Point a,Point b) +{ +return sgn(l.func(a))*sgn(l.func(b))<0; +} +int PntonSeg(LineSegment ls,Point p) +{ +Line l(ls.pt1,ls.pt2); +if (ls.pt1==p||ls.pt2==p) return 1; +if (sgn(l.func(p))==0&&((ls.pt1=0) + { + p[t].numv=0; + tot+=w[t]; + w[t]=0; + } +} +printf("%d\n",tot); +} +int main() +{ +while (scanf("%d",&n)!=EOF) + work(); +return 0; +} diff --git a/HDOJ/3292_autoAC.cpp b/HDOJ/3292_autoAC.cpp new file mode 100644 index 0000000..b7e93e7 --- /dev/null +++ b/HDOJ/3292_autoAC.cpp @@ -0,0 +1,71 @@ +#include +#include +using namespace std; +#define mod 8191 +const int maxn=5; +typedef struct +{ + int m[maxn][maxn]; +}Matrix; +int N,x,y; +void search() +{ + y=1; + while(1){ + x=sqrt(N*y*y+1.0); + if(x*x-N*y*y==1) break; + y++; + } +} +Matrix per,d; +void init() +{ + d.m[0][0]=x%mod; + d.m[0][1]=y*N%mod; + d.m[1][0]=y%mod; + d.m[1][1]=x%mod; + for(int i=0;i<2;i++) + for(int j=0;j<2;j++) + per.m[i][j]= (i==j); +} +Matrix Multi(Matrix a,Matrix b) +{ + Matrix c; + for(int i=0;i<2;i++) + for(int j=0;j<2;j++){ + c.m[i][j]=0; + for(int k=0;k<2;k++) + c.m[i][j]+=(a.m[i][k]*b.m[k][j])%mod; + c.m[i][j]%=mod; + } + return c; +} +Matrix power(Matrix a,int k) +{ + Matrix r=per; + while(k) + { + if(k&1) r=Multi(r,a); + a=Multi(a,a); + k>>=1; + } + return r; +} +int main() +{ + int k; + while(~scanf("%d%d",&N,&k)) + { + int tmp=sqrt(N+0.0); + if(tmp*tmp==N){ + printf("No answers can meet such conditions\n"); + continue; + } + search(); + init(); + d=power(d,k-1); + x=(d.m[0][0]*x%mod+d.m[0][1]*y%mod)%mod; + printf("%d\n",x); + } + return 0; +} diff --git a/HDOJ/3293_autoAC.cpp b/HDOJ/3293_autoAC.cpp new file mode 100644 index 0000000..49b491c --- /dev/null +++ b/HDOJ/3293_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +using namespace std; +struct NODE +{ + char name[30]; + char lv[30]; + char ori[30]; +} girl[505]; +int cmp(NODE x,NODE y) +{ + if(strcmp(x.ori,y.ori)) + return strcmp(x.ori,y.ori)<0; + if(strcmp(x.lv,y.lv)) + { + if(!strcmp(x.lv,"wonderful")) + return 1; + if(!strcmp(y.lv,"wonderful")) + return 0; + if(!strcmp(y.lv,"so-so")) + return 1; + if(!strcmp(x.lv,"so-so")) + return 0; + } + return strcmp(x.name,y.name)<0; +} +int main() +{ + int n,i,cas = 1; + while(~scanf("%d",&n)) + { + for(i = 0; i +#include +#include +#include +#include +#include +#include +#include +#define INF 99999999 +using namespace std; +const int MAX=200000+10; +char s[MAX*2],temp[2]; +int p[MAX*2]; +int main(){ + while(scanf("%s%s",temp,s)!=EOF){ + int len=strlen(s),id=0,maxid=0; + for(int i=len;i>=0;--i){ + s[i+i+2]=s[i]; + s[i+i+1]='#'; + } + s[0]='*'; + for(int i=2;i<2*len+1;++i){ + if(p[id]+id>i)p[i]=min(p[2*id-i],p[id]+id-i); + else p[i]=1; + while(s[i+p[i]] == s[i-p[i]])++p[i]; + if(id+p[id] +#include +#include +#include +#include +using namespace std; +struct Map +{ + int map[6][6]; +}star; +struct P +{ + int x, y; +}; +int n, m, ans; +int di[4][2] = {0,1, -1,0, 0,-1, 1,0}; +int check(struct Map &node) +{ + int i, j; + for( i = 0 ; i < n ; i++) + for( j = 0 ; j < m ; j++) + if( node.map[i][j] != 0) + return 0; + return 1; +} +int print( struct Map node) +{ + int i, j; + printf("\n"); + for( i = 0 ; i < n ; i++) + { + for( j = 0 ; j < m ; j++) + printf("%d ", node.map[i][j]); + printf("\n"); + } + printf("\n"); + return 0; +} +int moveh(struct Map &node) +{ + int i, j, flog, flog2, b; + flog2 = 0; + for( j = 0 ; j < m ; j++) + { + flog = 0; + for( i = 0 ; i < n ; i++) + if(node.map[i][j] != 0) + flog = 1; + if( flog == 1 && flog2 == 1) + { + for( i = 0 ; i < n ; i++) + node.map[i][b] = node.map[i][j]; + for( i = 0 ; i < n ; i++) + node.map[i][j] = 0; + b++; + }else if( flog == 0 && flog2 == 0) + { + flog2 = 1; + b = j; + } + } + return 0; +} +int moves(int s, struct Map &node) +{ + int i, j, flog, b; + flog = 0; + for( i = n - 1 ; i >= 0 ; i--) + { + if( node.map[i][s] == 0 && flog == 0) + { + b = i; + flog = 1; + } + else if( node.map[i][s] != 0 && flog == 1) + { + node.map[b][s] = node.map[i][s]; + node.map[i][s] = 0; + b--; + } + } + return 0; +} +int movemap( struct Map &node) +{ + int i; + for( i = 0 ; i < m ; i++) + moves(i, node); + moveh(node); + return 0; +} +int change_map(struct Map &node, int mark[][6], int x, int y) +{ + int i, j, l, num, flog; + queue Q; + struct P per, next; + per.x = x; + per.y = y; + num = node.map[x][y]; + mark[x][y] = true; + Q.push(per); + while(!Q.empty()) + { + per = Q.front(); + Q.pop(); + if( node.map[per.x][per.y] == 0) + continue; + node.map[per.x][per.y] = 0; + for(l = 0 ; l < 4 ; l++) + { + i = per.x + di[l][0]; + j = per.y + di[l][1]; + if( i < 0 || j < 0 || i >= n || j >= m) + continue; + next.x = i; + next.y = j; + if( node.map[i][j] == num) + { + Q.push(next); + mark[i][j] = true; + } + } + } + return 0; +} +int r_map(struct Map &a, struct Map &s) +{ + int i, j; + for( i = 0 ; i < n ; i++) + for( j = 0 ; j < m ; j++) + a.map[i][j] = s.map[i][j]; + return 0; +} +int DFS(int k, struct Map per) +{ + int i, j; + int mark[6][6]; + struct Map temp; + memset(mark, 0, sizeof(mark)); + if( check(per) == 1) + { + if( k < ans) + ans = k; + return 0; + } + for( i = 0 ; i < n ; i++) + { + for( j = 0 ; j < m ; j++) + { + if( per.map[i][j] == 0) + continue; + if( mark[i][j] == 0) + { + mark[i][j] = 1; + r_map( temp, per); + change_map(per, mark, i, j); + movemap(per); + DFS(k + 1, per); + r_map(per, temp); + } + } + } + return 0; +} +int input() +{ + int i, j; + for( i = 0 ; i < n ; i++) + for( j = 0 ; j < m ; j++) + scanf("%d", &star.map[i][j]); + return 0; +} +int main() +{ + int i, j; + while(scanf("%d%d", &n, &m) == 2) + { + input(); + ans = 65; + DFS(0, star); + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/3296_autoAC.cpp b/HDOJ/3296_autoAC.cpp new file mode 100644 index 0000000..a2c0426 --- /dev/null +++ b/HDOJ/3296_autoAC.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-9; +const double pi = 3.1415926535897932384626; +#define INF 1e18 +const int maxn = 2017; +int main() +{ + int s[maxn], t[maxn]; + int S, T, M; + int ID, P, Q; + int cas = 0; + while(scanf("%d%d%d",&S,&T,&M)) + { + if(S==0 && T==0 && M==0) + break; + memset(s,0,sizeof(s)); + memset(t,0,sizeof(t)); + int sum = 0; + for(int i = 1; i <= S; i++) + { + scanf("%d%d%d",&ID,&P,&Q); + sum+=P+Q; + } + int Sid, Tot; + for(int i = 1; i <= T; i++) + { + scanf("%d%d",&Sid,&Tot); + if(Tot >= M && t[Sid] == 0) + { + sum++; + t[Sid] = 1; + } + } + printf("Case %d: %d\n",++cas,sum); + } + return 0; +} diff --git a/HDOJ/3297_autoAC.cpp b/HDOJ/3297_autoAC.cpp new file mode 100644 index 0000000..3f8726d --- /dev/null +++ b/HDOJ/3297_autoAC.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define REP(i,s,t) for(int i=(s);i<=(t);i++) +#define REP2(i,t,s) for(int i=(t);i>=s;i--) +using namespace std; +typedef long long ll; +typedef unsigned long long ull; +typedef unsigned long ul; +const int N=20; +const int Maxans=10240+10; +int a[N]; +int bit[N]; +vectorG[Maxans]; +int state[1<<17]; +bool judge(int x) +{ + int cnt=0; + REP(i,1,16) + { + if(x&(1<<(i-1))) + { + bit[++cnt]=a[i]; + } + } + return cnt==4; +} +int fuck() +{ + REP(i,0,Maxans) + { + G[i].clear(); + } + memset(state,0,sizeof(state)); + sort(a+1,a+1+16); + REP(i,0,(1<<16)-1) + { + if(judge(i)) + { + do + { + int tmp=bit[1]*1+bit[2]*2+bit[3]*3+bit[4]*4; + for(int j=0;j +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include +#include +#include +#include +#include ; +#define cler(arr, val) memset(arr, val, sizeof(arr)) +typedef long long LL; +const int MAXN = 200010; +const int MAXM = 200006; +const int INF = 0x3f3f3f3f; +const int mod = 10000007; +LL point[MAXN],num[MAXN]; +vectoredge[MAXN]; +bool vis[MAXN]; +LL abs1(LL a) +{ + if(a>0) return a; + else return -a; +} +void dfs(int u) +{ + vis[u]=true; + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include +#include +#include +#include +#include ; +#define cler(arr, val) memset(arr, val, sizeof(arr)) +typedef long long LL; +const int MAXN = 100010; +const int MAXM = 20006; +const int INF = 0x3f3f3f3f; +const int mod = 10000007; +struct node +{ + int x,y; +}point[200]; +bool cmp(node a,node b) +{ + if(a.x==b.x) + return a.yy1&&point[k].y=y1&&point[k].y<=y2) on2[num]++; + } + if(num<=2) return n; + int maxv=0; + for(int k=1;k<=num;k++) + { + ans=max(ans,line[k]+on2[k]+maxv); + maxv=max(maxv,on1[k]-line[k]); + } + } + } + return ans; +} +int main() +{ + int t,cas=1; + while(scanf("%d",&t),t) + { + for(int i=0;i