From c14ecbe72c987cd332fb05b2a0df24154e58a950 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Sun, 4 Sep 2016 14:10:14 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 3400-3499 --- HDOJ/3400_autoAC.cpp | 67 ++++++++++++ HDOJ/3401_autoAC.cpp | 66 ++++++++++++ HDOJ/3402_autoAC.cpp | 35 ++++++ HDOJ/3403_autoAC.cpp | 104 ++++++++++++++++++ HDOJ/3404_autoAC.cpp | 50 +++++++++ HDOJ/3405_autoAC.cpp | 82 ++++++++++++++ HDOJ/3406_autoAC.cpp | 74 +++++++++++++ HDOJ/3407_autoAC.cpp | 103 ++++++++++++++++++ HDOJ/3408_autoAC.cpp | 130 ++++++++++++++++++++++ HDOJ/3409_autoAC.cpp | 107 +++++++++++++++++++ HDOJ/3410_autoAC.cpp | 48 +++++++++ HDOJ/3411_autoAC.cpp | 80 ++++++++++++++ HDOJ/3412_autoAC.cpp | 60 +++++++++++ HDOJ/3413_autoAC.cpp | 93 ++++++++++++++++ HDOJ/3414_autoAC.cpp | 50 +++++++++ HDOJ/3415_autoAC.cpp | 48 +++++++++ HDOJ/3416_autoAC.cpp | 208 ++++++++++++++++++++++++++++++++++++ HDOJ/3417_autoAC.cpp | 76 +++++++++++++ HDOJ/3418_autoAC.cpp | 37 +++++++ HDOJ/3419_autoAC.cpp | 79 ++++++++++++++ HDOJ/3420_autoAC.cpp | 18 ++++ HDOJ/3421_autoAC.cpp | 41 +++++++ HDOJ/3422_autoAC.cpp | 10 ++ HDOJ/3423_autoAC.cpp | 113 ++++++++++++++++++++ HDOJ/3424_autoAC.cpp | 17 +++ HDOJ/3425_autoAC.cpp | 172 ++++++++++++++++++++++++++++++ HDOJ/3426_autoAC.cpp | 88 +++++++++++++++ HDOJ/3427_autoAC.cpp | 69 ++++++++++++ HDOJ/3429_autoAC.cpp | 195 +++++++++++++++++++++++++++++++++ HDOJ/3430_autoAC.cpp | 76 +++++++++++++ HDOJ/3432_autoAC.cpp | 64 +++++++++++ HDOJ/3433_autoAC.cpp | 53 +++++++++ HDOJ/3434_autoAC.cpp | 38 +++++++ HDOJ/3435_autoAC.cpp | 96 +++++++++++++++++ HDOJ/3436_autoAC.cpp | 249 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/3437_autoAC.cpp | 117 ++++++++++++++++++++ HDOJ/3439_autoAC.cpp | 130 ++++++++++++++++++++++ HDOJ/3440_autoAC.cpp | 92 ++++++++++++++++ HDOJ/3441_autoAC.cpp | 154 ++++++++++++++++++++++++++ HDOJ/3442_autoAC.cpp | 140 ++++++++++++++++++++++++ HDOJ/3443_autoAC.cpp | 14 +++ HDOJ/3446_autoAC.cpp | 170 +++++++++++++++++++++++++++++ HDOJ/3448_autoAC.cpp | 40 +++++++ HDOJ/3449_autoAC.cpp | 30 ++++++ HDOJ/3450_autoAC.cpp | 69 ++++++++++++ HDOJ/3451_autoAC.cpp | 121 +++++++++++++++++++++ HDOJ/3452_autoAC.cpp | 55 ++++++++++ HDOJ/3455_autoAC.cpp | 45 ++++++++ HDOJ/3456_autoAC.cpp | 33 ++++++ HDOJ/3457_autoAC.cpp | 56 ++++++++++ HDOJ/3458_autoAC.cpp | 49 +++++++++ HDOJ/3459_autoAC.cpp | 202 +++++++++++++++++++++++++++++++++++ HDOJ/3460_autoAC.cpp | 67 ++++++++++++ HDOJ/3461_autoAC.cpp | 58 ++++++++++ HDOJ/3462_autoAC.cpp | 138 ++++++++++++++++++++++++ HDOJ/3463_autoAC.cpp | 138 ++++++++++++++++++++++++ HDOJ/3464_autoAC.cpp | 61 +++++++++++ HDOJ/3465_autoAC.cpp | 79 ++++++++++++++ HDOJ/3466_autoAC.cpp | 46 ++++++++ HDOJ/3467_autoAC.cpp | 218 +++++++++++++++++++++++++++++++++++++ HDOJ/3468_autoAC.cpp | 197 ++++++++++++++++++++++++++++++++++ HDOJ/3469_autoAC.cpp | 19 ++++ HDOJ/3470_autoAC.cpp | 76 +++++++++++++ HDOJ/3471_autoAC.cpp | 76 +++++++++++++ HDOJ/3472_autoAC.cpp | 189 ++++++++++++++++++++++++++++++++ HDOJ/3473_autoAC.cpp | 97 +++++++++++++++++ HDOJ/3475_autoAC.cpp | 134 +++++++++++++++++++++++ HDOJ/3476_autoAC.cpp | 5 + HDOJ/3478_autoAC.cpp | 80 ++++++++++++++ HDOJ/3480_autoAC.cpp | 67 ++++++++++++ HDOJ/3481_autoAC.cpp | 39 +++++++ HDOJ/3482_autoAC.cpp | 40 +++++++ HDOJ/3483_autoAC.cpp | 57 ++++++++++ HDOJ/3484_autoAC.cpp | 88 +++++++++++++++ HDOJ/3485_autoAC.cpp | 24 +++++ HDOJ/3486_autoAC.cpp | 59 ++++++++++ HDOJ/3487_autoAC.cpp | 174 ++++++++++++++++++++++++++++++ HDOJ/3488_autoAC.cpp | 75 +++++++++++++ HDOJ/3489_autoAC.cpp | 38 +++++++ HDOJ/3490_autoAC.cpp | 46 ++++++++ HDOJ/3491_autoAC.cpp | 128 ++++++++++++++++++++++ HDOJ/3492_autoAC.cpp | 66 ++++++++++++ HDOJ/3493_autoAC.cpp | 56 ++++++++++ HDOJ/3496_autoAC.cpp | 43 ++++++++ HDOJ/3497_autoAC.cpp | 14 +++ HDOJ/3498_autoAC.cpp | 157 +++++++++++++++++++++++++++ HDOJ/3499_autoAC.cpp | 102 ++++++++++++++++++ 87 files changed, 7364 insertions(+) create mode 100644 HDOJ/3400_autoAC.cpp create mode 100644 HDOJ/3401_autoAC.cpp create mode 100644 HDOJ/3402_autoAC.cpp create mode 100644 HDOJ/3403_autoAC.cpp create mode 100644 HDOJ/3404_autoAC.cpp create mode 100644 HDOJ/3405_autoAC.cpp create mode 100644 HDOJ/3406_autoAC.cpp create mode 100644 HDOJ/3407_autoAC.cpp create mode 100644 HDOJ/3408_autoAC.cpp create mode 100644 HDOJ/3409_autoAC.cpp create mode 100644 HDOJ/3410_autoAC.cpp create mode 100644 HDOJ/3411_autoAC.cpp create mode 100644 HDOJ/3412_autoAC.cpp create mode 100644 HDOJ/3413_autoAC.cpp create mode 100644 HDOJ/3414_autoAC.cpp create mode 100644 HDOJ/3415_autoAC.cpp create mode 100644 HDOJ/3416_autoAC.cpp create mode 100644 HDOJ/3417_autoAC.cpp create mode 100644 HDOJ/3418_autoAC.cpp create mode 100644 HDOJ/3419_autoAC.cpp create mode 100644 HDOJ/3420_autoAC.cpp create mode 100644 HDOJ/3421_autoAC.cpp create mode 100644 HDOJ/3422_autoAC.cpp create mode 100644 HDOJ/3423_autoAC.cpp create mode 100644 HDOJ/3424_autoAC.cpp create mode 100644 HDOJ/3425_autoAC.cpp create mode 100644 HDOJ/3426_autoAC.cpp create mode 100644 HDOJ/3427_autoAC.cpp create mode 100644 HDOJ/3429_autoAC.cpp create mode 100644 HDOJ/3430_autoAC.cpp create mode 100644 HDOJ/3432_autoAC.cpp create mode 100644 HDOJ/3433_autoAC.cpp create mode 100644 HDOJ/3434_autoAC.cpp create mode 100644 HDOJ/3435_autoAC.cpp create mode 100644 HDOJ/3436_autoAC.cpp create mode 100644 HDOJ/3437_autoAC.cpp create mode 100644 HDOJ/3439_autoAC.cpp create mode 100644 HDOJ/3440_autoAC.cpp create mode 100644 HDOJ/3441_autoAC.cpp create mode 100644 HDOJ/3442_autoAC.cpp create mode 100644 HDOJ/3443_autoAC.cpp create mode 100644 HDOJ/3446_autoAC.cpp create mode 100644 HDOJ/3448_autoAC.cpp create mode 100644 HDOJ/3449_autoAC.cpp create mode 100644 HDOJ/3450_autoAC.cpp create mode 100644 HDOJ/3451_autoAC.cpp create mode 100644 HDOJ/3452_autoAC.cpp create mode 100644 HDOJ/3455_autoAC.cpp create mode 100644 HDOJ/3456_autoAC.cpp create mode 100644 HDOJ/3457_autoAC.cpp create mode 100644 HDOJ/3458_autoAC.cpp create mode 100644 HDOJ/3459_autoAC.cpp create mode 100644 HDOJ/3460_autoAC.cpp create mode 100644 HDOJ/3461_autoAC.cpp create mode 100644 HDOJ/3462_autoAC.cpp create mode 100644 HDOJ/3463_autoAC.cpp create mode 100644 HDOJ/3464_autoAC.cpp create mode 100644 HDOJ/3465_autoAC.cpp create mode 100644 HDOJ/3466_autoAC.cpp create mode 100644 HDOJ/3467_autoAC.cpp create mode 100644 HDOJ/3468_autoAC.cpp create mode 100644 HDOJ/3469_autoAC.cpp create mode 100644 HDOJ/3470_autoAC.cpp create mode 100644 HDOJ/3471_autoAC.cpp create mode 100644 HDOJ/3472_autoAC.cpp create mode 100644 HDOJ/3473_autoAC.cpp create mode 100644 HDOJ/3475_autoAC.cpp create mode 100644 HDOJ/3476_autoAC.cpp create mode 100644 HDOJ/3478_autoAC.cpp create mode 100644 HDOJ/3480_autoAC.cpp create mode 100644 HDOJ/3481_autoAC.cpp create mode 100644 HDOJ/3482_autoAC.cpp create mode 100644 HDOJ/3483_autoAC.cpp create mode 100644 HDOJ/3484_autoAC.cpp create mode 100644 HDOJ/3485_autoAC.cpp create mode 100644 HDOJ/3486_autoAC.cpp create mode 100644 HDOJ/3487_autoAC.cpp create mode 100644 HDOJ/3488_autoAC.cpp create mode 100644 HDOJ/3489_autoAC.cpp create mode 100644 HDOJ/3490_autoAC.cpp create mode 100644 HDOJ/3491_autoAC.cpp create mode 100644 HDOJ/3492_autoAC.cpp create mode 100644 HDOJ/3493_autoAC.cpp create mode 100644 HDOJ/3496_autoAC.cpp create mode 100644 HDOJ/3497_autoAC.cpp create mode 100644 HDOJ/3498_autoAC.cpp create mode 100644 HDOJ/3499_autoAC.cpp diff --git a/HDOJ/3400_autoAC.cpp b/HDOJ/3400_autoAC.cpp new file mode 100644 index 0000000..1e3aff4 --- /dev/null +++ b/HDOJ/3400_autoAC.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +using namespace std; +struct point +{ + double x,y; +}; +const double eps=1e-4; +double p,q,r; +double dis(point a,point b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +double cal_ab(point a,point b,point m) +{ + point left=a,right=b; + point mid,midmid; + double ans1,ans2; + do + { + mid.x=(left.x+right.x)/2.0; + mid.y=(left.y+right.y)/2.0; + midmid.x=(left.x+mid.x)/2.0; + midmid.y=(left.y+mid.y)/2.0; + ans1=dis(mid,a)/p+dis(mid,m)/r; + ans2=dis(midmid,a)/p+dis(midmid,m)/r; + if(ans1eps); + return ans1; +} +double cal_abcd(point a,point b,point c,point d) +{ + point left=c,right=d; + point m,mm; + double ans1,ans2; + do + { + m.x=(left.x+right.x)/2.0; + m.y=(left.y+right.y)/2.0; + mm.x=(left.x+m.x)/2.0; + mm.y=(left.y+m.y)/2.0; + ans1=dis(m,d)/q+cal_ab(a,b,m); + ans2=dis(mm,d)/q+cal_ab(a,b,mm); + if(ans1eps); + return ans1; +} +int main() +{ + int t; + point a,b,c,d; + scanf("%d",&t); + while(t--) + { + scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&a.x,&a.y,&b.x,&b.y,&c.x,&c.y,&d.x,&d.y); + scanf("%lf%lf%lf",&p,&q,&r); + printf("%.2lf\n",cal_abcd(a,b,c,d)); + } + return 0; +} diff --git a/HDOJ/3401_autoAC.cpp b/HDOJ/3401_autoAC.cpp new file mode 100644 index 0000000..73b8692 --- /dev/null +++ b/HDOJ/3401_autoAC.cpp @@ -0,0 +1,66 @@ +#include +#include +const int MAXN = 2000 + 123; +int ap[MAXN], bp[MAXN], as[MAXN], bs[MAXN]; +int f[MAXN][MAXN]; +struct node +{ + int num, val; +}q[MAXN]; +inline int min(int x,int y) +{ + return xy?x:y; +} +int main() +{ + int T; + scanf("%d", &T); + while(T--) + { + int t, maxp, w; + scanf("%d%d%d", &t, &maxp, &w); + for(int i = 1; i <= t; i++) scanf("%d%d%d%d",&ap[i], &bp[i], &as[i], &bs[i]); + memset(f, 200, sizeof(f)); + for(int i = 1; i <= w + 1; i++) + for(int j = 0; j <= min(as[i], maxp); j++) + { + f[i][j] = -ap[i] * j; + } + for(int i = 2; i <= t; i++) + { + for(int j = 0; j <= maxp; j++) f[i][j] = max(f[i][j], f[i-1][j]); + if(i < w + 2) continue; + int head = 0, tail = -1; + q[++tail].num = 0; + q[tail].val = f[i - w - 1][0]; + for(int j = 1; j <= maxp; j++) + { + while(tail >= head && j - q[head].num > as[i]) head++; + if(head <= tail) f[i][j] = max(f[i][j], q[head].val - (j - q[head].num) * ap[i]); + while(tail >= head && q[tail].val + (q[tail].num - j) * ap[i] < f[i - w - 1][j]) tail--; + q[++tail].num = j; + q[tail].val = f[i- w - 1][j]; + } + head = 0, tail = -1; + q[++tail].num = maxp; + q[tail].val = f[i - w - 1][maxp]; + for(int j = maxp - 1; j >= 0; j--) + { + while(tail >= head && q[head].num - j > bs[i]) head++; + if(head <= tail) f[i][j] = max(f[i][j], q[head].val + (q[head].num - j) * bp[i]); + while(tail >= head && q[tail].val + (q[tail].num - j) * bp[i] < f[i - w - 1][j]) tail--; + q[++tail].num = j; + q[tail].val = f[i - w - 1][j]; + } + } + int rmax = 0; + for(int i = 0; i <= maxp; i++) + if(f[t][i] > rmax) rmax = f[t][i]; + printf("%d\n", rmax); + } + return 0; +} diff --git a/HDOJ/3402_autoAC.cpp b/HDOJ/3402_autoAC.cpp new file mode 100644 index 0000000..7183eca --- /dev/null +++ b/HDOJ/3402_autoAC.cpp @@ -0,0 +1,35 @@ +#include +#include +#include +#include +using namespace std; +double PI = 3.1415926 * 2; +int t,n; +double r; +double dis_tance; +double minn; +int map[100010]; +int main() +{ + scanf("%d",&t); + while(t --) + { + minn = 100000.00; + scanf("%d%lf",&n,&r); + memset(map,0,sizeof(map)); + for(int i = 1;i <= n;i ++) + scanf("%d",&map[i]); + if(map[1] == map[n]) + printf("inf\n"); + else + { + sort(map + 1,map + n + 1); + dis_tance = (PI * r) / n; + for(int i = n;i > 1;i --) + if(dis_tance / (map[i] - map[i - 1]) < minn) + minn = dis_tance / (map[i] - map[i - 1]); + printf("%.3lf\n",minn); + } + } + return 0; +} diff --git a/HDOJ/3403_autoAC.cpp b/HDOJ/3403_autoAC.cpp new file mode 100644 index 0000000..11bd929 --- /dev/null +++ b/HDOJ/3403_autoAC.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef pair pii; +int day[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; +bool isLeap(long long year) +{ + return year % 400 == 0 || year % 4 == 0 && year % 100 != 0; +} +vector ht; +vector pvt[10]; +vector leapVt[10]; +int sum[10]; +int rev(int t) +{ + char str[10]; + sprintf(str, "%04d", t); + reverse(str, str+4); + return atoi(str); +} +void init() +{ + for (int mm = 1; mm <= 12; mm++) { + for (int dd = 1; dd <= day[mm]; dd++) { + if (dd % 10 == 0) continue; + int t = mm*100 + dd; + ht.push_back(pii(rev(t), t)); + } + } + sort(ht.begin(), ht.end()); + long long now = 9220; + for (int n = 0; n <= 7; n++, now *= 10) {//9220*..*0229 + if (n == 0) { + pvt[n].push_back(""); + leapVt[n].push_back(""); + } else if (n == 1) { + for (char i = '0'; i <= '9'; i++) { + pvt[n].push_back(string(1, i));// + int year = now+(i-'0'); + if (isLeap(year)) { + leapVt[n].push_back(pvt[n].back()); + } + } + } else { + int nn = n - 2; + for (char i = '0'; i <= '9'; i++) { + for (vector::iterator it = pvt[nn].begin(); it != pvt[nn].end(); it++) { + pvt[n].push_back(i+*it+i); + long long year = now+atoi(pvt[n].back().c_str()); + if (isLeap(year)) { + leapVt[n].push_back(pvt[n].back()); + } + } + } + } + sum[n] = 330*pvt[n].size() + leapVt[n].size(); + } +} +int main() +{ + init(); + int T, k, n; + for (scanf("%d", &T); T--; ) { + scanf("%d", &k); + k--; + for (n = 0; n <= 7; n++) { + if (k < sum[n]) break; + else k -= sum[n]; + } + int num = pvt[n].size(); + if (k >= 322*num) { + k -= 322*num; + if (k < leapVt[n].size()) { + printf("9220%s0229\n", leapVt[n][k].c_str()); + } else { + k -= leapVt[n].size(); + int p = k/num + 322; + printf("%d%s%04d\n", ht[p].first, pvt[n][k%num].c_str(), ht[p].second); + } + } else { + int p = k/num; + printf("%d%s%04d\n", ht[p].first, pvt[n][k%num].c_str(), ht[p].second); + } + } + return 0; +} diff --git a/HDOJ/3404_autoAC.cpp b/HDOJ/3404_autoAC.cpp new file mode 100644 index 0000000..7597fbd --- /dev/null +++ b/HDOJ/3404_autoAC.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#define N 2000000 +using namespace std; +int m[2][2]={0,0,0,1}; +int Nim_Mult_Power(int x,int y){ + if(x<2) + return m[x][y]; + int a=0; + for(;;a++) + if(x>=(1<<(1<=(1<<(1< +#include +#include +#include +#include +const int inf=99999991; +using namespace std; +double map[55][55],dis[55]; +int n; +bool vs[55]; +struct Node +{ + int x,y; +}node[55]; +double Min(double a,double b) +{ + if(a>b)return b; + else return a; +} +double prim(int x) +{ + int i,k,mark; + memset(vs,0,sizeof(vs)); + vs[x]=1; + for(i=0;idis[i]) + { + MIN=dis[i]; + mark=i; + } + SUM+=MIN; + vs[mark]=1; + for(i=0;imap[mark][i]) + dis[i]=map[mark][i]; + } + return SUM; +} +int main() +{ + int i,j,CASE; + double d,x1,y1; + scanf("%d",&CASE); + while(CASE--) + { + scanf("%d",&n); + for(i=0;i=0;j--) + { + x1=node[i].x-node[j].x; + y1=node[i].y-node[j].y; + d=sqrt(x1*x1+y1*y1); + map[i][j]=map[j][i]=d; + } + } + double h,g=inf; + for(i=0;i +#include +#include +using namespace std; +int dp[(1<<16)+2][10][4]; +int map[17][17]; +int bit[(1<<16)+2]; +int main() +{ + int i,j,n,cnt,k,l,m,p,a,ans; + for (i=0;i<(1<<16);i++) + { + cnt=0; + for (j=0;j<16;j++) + { + if ((i & (1< +#include +#include +#include +#include +#define MAXN 100006 +#define kind 26 +using namespace std; +char word[MAXN]; +struct Node +{ + int next[kind],v,fail; +}Trie[5*MAXN+10]; +int snode; +int N; +int cas; +void set_node(int x) +{ + memset(Trie[x].next,0,sizeof(Trie[x].next)); + Trie[x].v=0; + Trie[x].fail=0; +} +void Insert(char s[]) +{ + int i=0,pos=0,index; + int len=strlen(s); + for(i=0;iQ; +void Build_AC_Fail() +{ + int i,pos; + while(!Q.empty()) Q.pop(); + Trie[0].fail=-1; + Q.push(0); + while(!Q.empty()) + { + pos=Q.front();Q.pop(); + for(i=0;i +#include +#include +#include +using namespace std; +typedef complex point; +const int maxn = 15; +const double eps = 1e-8; +const double pi = acos( -1.0 ); +struct line +{ + point a, b; + line( ){ } + line( point u, point v ) : a( u ), b( v ) { } +}; +struct polygon +{ + point p[maxn]; + int n; +}; +int dblcmp( double x ){ return ( x < -eps ? -1 : x > eps ); } +double operator^( point p1, point p2 ){ return imag( conj( p1 ) * p2 ); } +double operator&( point p1, point p2 ){ return real( conj( p1 ) * p2 ); } +point operator*( line l0, line l1 ) +{ + double t = l0.a - l1.a ^ l0.b - l1.a; + double s = l0.b - l1.b ^ l0.a - l1.b; + return l1.a + ( l1.b - l1.a ) * t / ( t + s ); +} +polygon poly[10]; +bool same_point( point p1, point p2 ) +{ + return dblcmp( imag( p1 ) - imag( p2 ) ) == 0 && dblcmp( real( p1 ) - real( p2 ) ) == 0; +} +bool on_radial( point p, line l ) +{ + if( dblcmp( l.a - p ^ l.b - p ) != 0 )return false; + return dblcmp( p - l.a & l.b - l.a ) >= 0; +} +bool on_segment( point p, line l ) +{ + if( dblcmp( l.a - p ^ l.b - p ) != 0 )return false; + return dblcmp( l.a - p & l.b - p ) <= 0; +} +int main( ) +{ + int i, j, n, m, sz, len; + double x, y, dx, dy; + point ss, kk, pp, pp1; + point xp[200]; + line L, L0; + while( scanf("%d",&n) && n ) + { + scanf("%lf%lf",&x, &y); + ss = point( x, y ); + scanf("%lf%lf",&dx, &dy); + kk = point( dx, dy ); + L.a = ss; + L.b = ss + kk; + pp = ss; + for( i = 0; i < n; i++ ) + { + scanf("%d",&m); + poly[i].n = m; + for( j = 0; j < m; j++ ) + { + scanf("%lf%lf",&x, &y); + poly[i].p[j] = point( x, y ); + } + poly[i].p[m] = poly[i].p[0]; + } + sz = poly[0].n; + for( i = 0; i < sz; i++ ) + { + L0 = line( poly[0].p[i], poly[0].p[i+1] ); + if( dblcmp( L.b - L.a ^ L0.b - L0.a ) == 0 ) + { + if( on_radial( L0.a, L ) ) + { + if( abs( L0.a - ss ) < abs( L0.b - ss ) ) pp = L0.a; + else pp = L0.b; + break; + } + } + else + { + pp1 = L0 * L; + if( on_radial( pp1, L ) && on_segment( pp1, L0 ) ) + { + if( same_point( pp , ss ) ) + pp = pp1; + else if( abs( pp1 - ss ) < abs( pp - ss ) ) + pp = pp1; + } + } + } + if( same_point( pp, ss ) ) + { + printf("MISS\n"); + continue; + } + len = 0; + for( i = 0; i < n; i++ ) + { + sz = poly[i].n; + for( j = 0; j < sz; j++ ) + { + L0 = line( poly[i].p[j], poly[i].p[j+1] ); + if( dblcmp( L.b - L.a ^ L0.b - L0.a ) == 0 ) + { + if( on_radial( L0.a, L ) ) + xp[len++] = L0.a, xp[len++] = L0.b; + } + else + { + pp1 = L0 * L; + if( on_segment( pp1, L0 ) ) + xp[len++] = pp1; + } + } + } + double min = 1e10; + for( i = 0; i < len; i++ ) + if( abs( xp[i] - ss ) < min ) + pp1 = xp[i], min = abs( xp[i] - ss ); + if( same_point( pp, pp1 ) )printf("HIT\n"); + else printf("MISS\n"); + } + return 0; +} diff --git a/HDOJ/3409_autoAC.cpp b/HDOJ/3409_autoAC.cpp new file mode 100644 index 0000000..d8f5fe0 --- /dev/null +++ b/HDOJ/3409_autoAC.cpp @@ -0,0 +1,107 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 205; +const int maxe = 20500; +const int INF = 0x3f3f3f; +struct Edge{ + int u,v,w; + int next; + void assign(int u_,int v_,int w_,int next_){ + u = u_; v = v_; w = w_; next = next_; + } + bool operator < (const Edge& e) const { + return w > e.w; + } +}edges[maxe]; +int head[maxn]; +vector G[maxn]; +int cnt; +int N,M,P; +double PT[maxn][maxn/2]; +double dp[maxn][maxn/2]; +void addedge(int u,int v,int w){ + edges[cnt].assign(u,v,w,head[u]); + head[u] = cnt++; + edges[cnt].assign(v,u,w,head[v]); + head[v] = cnt++; +} +void Dijkstra(){ + priority_queue Q; + int d[maxn]; + bool vis[maxn]; + memset(d,0x3f,sizeof(d)); + memset(vis,0,sizeof(vis)); + for(int i=0;i d[u] + edges[i].w){ + d[v] = d[u] + edges[i].w; + Q.push((Edge){v,u,d[v]}); + } + } + } +} +void dfs(int u){ + int child = G[u].size(); + double son[maxn]; + for(int i=0;i<=P;i++) son[i] = 0; + if(child == 0){ + for(int i=1;i<=P;i++){ + dp[u][i] = PT[u][i]; + } + return; + } + for(int i=0;i=0;j--) + for(int k=0;k<=j;k++) + son[j] = max(son[j],dp[v][k]/child+son[j-k]); + } + for(int i=P;i>=0;i--) + for(int j=0;j<=i;j++){ + dp[u][i] = max(dp[u][i],PT[u][j] + (1-PT[u][j])* son[i-j]); + } +} +int main() +{ + while(scanf("%d%d",&N,&M) == 2 && N+M){ + cnt = 0; + memset(dp,0,sizeof(dp)); + memset(head,-1,sizeof(head)); + for(int i=1;i<=M;i++){ + int a,b,c; + scanf("%d%d%d",&a,&b,&c); + if(a == b) continue; + addedge(a,b,c); + } + scanf("%d",&P); + for(int i=0;i +#include +#include +using namespace std; +const int MAXN = 50010; +int main() +{ + int iCase, n, ic = 1; + int arr[MAXN], que[MAXN]; + int rear, front; + int l[MAXN], r[MAXN]; + bool flag; + scanf("%d", &iCase); + while (iCase--) { + arr[0] = 0; + memset(que, 0, sizeof(que)); + scanf("%d", &n); + for (int i = 1; i <= n; ++i) + scanf("%d", &arr[i]); + front = 0, rear = -1; + for (int i = 1; i <= n; ++i) { + flag = false; + while (front <= rear && arr[que[rear]] < arr[i]) { + flag = true; + rear--; + } + if (flag) l[i] = que[rear+1]; + else l[i] = 0; + que[++rear] = i; + } + front = 0, rear = -1; + for (int i = n; i >= 1; --i) { + flag = false; + while (front <= rear && arr[que[rear]] < arr[i]) { + flag = true; + rear--; + } + if (flag) r[i] = que[rear+1]; + else r[i] = 0; + que[++rear] = i; + } + printf("Case %d:\n", ic++); + for (int i = 1; i <= n; ++i) { + printf("%d %d\n", l[i], r[i]); + } + } + return 0; +} diff --git a/HDOJ/3411_autoAC.cpp b/HDOJ/3411_autoAC.cpp new file mode 100644 index 0000000..260e4cb --- /dev/null +++ b/HDOJ/3411_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#define N 50005 +#define M 30 +#define read(a,b,c) scanf("%d%d%d",&a,&b,&c) +#define cl(a) memset(a,0,sizeof(a)) +#define ll long long +ll x[M],f[3],r[N][3][3],q; +int p; +using namespace std; +ll bin(ll t) +{ + ll res=1; + int i=0; + while (t>0) + { + if (t&1) res=(res*x[i])%p; + i++; + t>>=1; + } + return res; +} +void init() +{ + r[0][1][1]=(q-1+p)%p; + r[0][1][2]=q; + r[0][2][1]=1; + r[0][2][2]=0; + f[1]=1;f[2]=0; +} +void mul(int t) +{ + int i,j,k; + for (i=1;i<=2;i++) + for (j=1;j<=2;j++) + { + r[t][i][j]=0; + for (k=1;k<=2;k++) r[t][i][j]=r[t][i][j]+(r[t-1][i][k]*r[t-1][k][j])%p; + } +} +void zmul(int i) +{ + ll g1,g2; + g1=(f[1]*r[i][1][1])%p+(f[2]*r[i][1][2])%p; + g2=(f[1]*r[i][2][1])%p+(f[2]*r[i][2][2])%p; + f[1]=g1%p;f[2]=g2%p; +} +void bin2(int t) +{ + int i=0; + while (t>0) + { + if (t&1) zmul(i); + t>>=1; + i++; + } +} +int main() +{ + int x1,y1,z1,y2,z2,i,j; + while (read(x1,y1,z1)!=EOF) + { + if (x1==-1&&y1==-1&&z1==-1) break; + read(y2,z2,p); + cl(x); + x[0]=x1%p; + for (i=1;i0) bin2(z2-1); + if (z2>=1) printf("%d\n",f[1]); + else printf("%d\n",f[2]); + } + return 0; +} diff --git a/HDOJ/3412_autoAC.cpp b/HDOJ/3412_autoAC.cpp new file mode 100644 index 0000000..4cddb31 --- /dev/null +++ b/HDOJ/3412_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +using namespace std; +struct T +{ + string name; + int s; +}t[200]; +string stu[200]; +bool flag; +int n; +bool cmp(T a,T b) +{ + return a.s>b.s; +} +bool cmp2(string a,string b) +{ + return a=n) return; + for(int i=x+1;i=0&&step+1<=3) dfs(i,sum-t[i].s,step+1); + } + return; +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + for(int i=0;i>t[i].name>>t[i].s; + sort(t,t+n,cmp); + int k=0; + for(int i=n-3;i>=0;i--) + { + flag=false; + dfs(i,t[i].s,0); + if(flag) stu[k]=t[i].name,k++; + } + sort(stu,stu+k,cmp2); + cout< +#include +#include +#include +#include +using namespace std; +double task[105]; +double ans[105]; +bool vis[105]; +int main() +{ + ios::sync_with_stdio(false); + int T; + cin>>T; + int kase=0; + while(T--) + { + cout<<"Case "<<++kase<<':'<>n; + for(int i=0;i>task[i]; + } + double now=0; + int pre=0; + for(int i=0;i1) + for(int j=(pre+1)%n;j!=pre;++j) + { + j%=n; + if(j==pre)break; + if(vis[j])continue; + if(task[j]<=1){rec=j;break;} + if(floor(task[j]) +const int N = 1000; +bool g[N][N]; +int n , next[N]; +bool expand( int s ) +{ + for( int i = 0 ; i < n ; next[i++] = -1 ); + int front = s , back = front; + for( int i = 0 ; i < n ; i++ ) + { + if( i == s ) continue; + if( g[i][front] ) next[i] = front , front = i; + else + { + int a = front , b = next[front]; + while( b != -1 && g[b][i] ) + a = b , b = next[b]; + next[a] = i; + next[i] = b; + if( b == -1 ) back = i; + } + } + if( g[back][front] ) + { + next[back] = front; + return true; + } + return false; +} +bool solve() +{ + for( int i = 0 ; i < n ; i++ ) + if( expand(i) ) return true; + return false; +} +int main() +{ + while( scanf("%d",&n) , n ) + { + for( int i = 0 ; i < n ; i++ ) + for( int j = 0 ; j < n ; j++ ) + scanf("%d",&g[i][j]); + if( n == 1 ) puts("1"); + else if( n == 2 || !solve() ) puts("-1"); + else + for( int i = 0 , j = 0 ; i < n ; i++ , j = next[j] ) + printf("%d%c",j+1,i==n-1?'\n':' '); + } + return 0; +} diff --git a/HDOJ/3415_autoAC.cpp b/HDOJ/3415_autoAC.cpp new file mode 100644 index 0000000..53e6a75 --- /dev/null +++ b/HDOJ/3415_autoAC.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +#include +using namespace std; +int a[111111]; +int sum[211111]; +const int INF = 0x3fffffff; +int main() +{ + int t,n,m,i,j,k,head,end; + scanf("%d",&t); + while(t--) + { + scanf("%d%d",&n,&k); + j = n; + sum[0] = 0; + for(i = 1; i<=n; i++) + { + scanf("%d",&a[i]); + sum[i] = sum[i-1]+a[i]; + } + int ans = -INF; + for(i = n+1; i Q; + Q.clear(); + for(i = 1; i<=n; i++) + { + while(!Q.empty() && sum[i-1]ans) + { + ans = sum[i]-sum[Q.front()]; + head = Q.front()+1; + end = i; + } + } + if(end>j) + end%=j; + printf("%d %d %d\n",ans,head,end); + } + return 0; +} diff --git a/HDOJ/3416_autoAC.cpp b/HDOJ/3416_autoAC.cpp new file mode 100644 index 0000000..81d72d0 --- /dev/null +++ b/HDOJ/3416_autoAC.cpp @@ -0,0 +1,208 @@ +#include +#include +#include +#include +#include +using namespace std; +#define clr(x)memset(x,0,sizeof(x)) +#define min(a,b)(a)<(b)?(a):(b) +const int INF=INT_MAX; +const int maxn=1005; +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=1;i<=n;i++) + { + d[i]=n; + cnt[i]=0; + } + cnt[n]=n-1; + cnt[0]++; + d[t]=0; + *rear++=t; + while(front0) + { + 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=1;i<=n;i++) + cur[i]=head[i]; + while(d[s]0&&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]dis; +int d1[maxn]; +int d2[maxn]; +void dijkstra(int u,int*d,int*hed,EDGE*ed,int&t) +{ + int i; + in.xu = u; + in.di = 0; + d[u] = 0; + dis.push(in); + while(!dis.empty()) + { + x = dis.top(); + dis.pop(); + for(i = hed[x.xu]; i; i = ed[i].next){ + in.xu = ed[i].to; + in.di = x.di+ed[i].w; + if(in.di < d[in.xu]){ + d[in.xu] = in.di; + dis.push(in); + } + } + } +} +int main() +{ + int T, i; + int n, m, st, en; + scanf("%d",&T); + while(T--) + { + scanf("%d %d",&n, &m); + clr(head2); + clr(head3); + tt = 1; + t3 = 1; + int a,b,c; + while(m--) + { + scanf("%d %d %d",&a, &b, &c); + add2(a,b,c); + add3(b,a,c); + } + scanf("%d %d",&st,&en); + for(i = 1; i <= n; i++) + d2[i] = d1[i] = INF; + dijkstra(st,d1,head2,edge,tt); + dijkstra(en,d2,head3,ee,t3); + memset(head,-1,sizeof(head)); + tot = 0; + for(i = 1; i < tt; i++) + { + if(d1[edge[i].from]+d2[edge[i].to]+edge[i].w == d1[en]) + add(edge[i].from,edge[i].to,1,0); + } + int res = maxflow(st,en,n); + printf("%d\n",res); + } + return 0; +} diff --git a/HDOJ/3417_autoAC.cpp b/HDOJ/3417_autoAC.cpp new file mode 100644 index 0000000..1c121aa --- /dev/null +++ b/HDOJ/3417_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#define ll __int64 +ll M=19880502ll,A[6],B[6][9999]; +int n,v[9999]; +ll gcd(ll a,ll b) +{ + if(!b)return a; + return gcd(b,a%b); +} +ll egcd(ll a,ll b,ll &x,ll &y) +{ + if(!b){x=1;y=0;return a;} + ll d=egcd(b,a%b,x,y),t=x; + x=y; + y=t-a/b*y; + return d; +} +ll Pow(ll a,ll b) +{ + ll r=1; + while(b) + { + if(b&1)r=r*a%M; + a=a*a%M; + b>>=1; + } + return r; +} +ll sol(int k) +{ + ll x,y,t=B[0][k],m=A[0]; + for(int i=1;i1){v[tp]=1;B[i][tp]=1;} + } + ll res=1; + for(int i=2;i<9998;i++) + if(v[i]) + { + ll t=sol(i); + if(!~t){res=-1;break;} + res=res*Pow((ll)i,t)%M; + } + printf("%I64d\n",res); + } +} diff --git a/HDOJ/3418_autoAC.cpp b/HDOJ/3418_autoAC.cpp new file mode 100644 index 0000000..d6dd863 --- /dev/null +++ b/HDOJ/3418_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include +using namespace std; +typedef __int64 LL; +const LL INF = 0x3f3f3f3f3f3f3f3fLL; +LL a[105]; +int judge(LL mid,LL n,LL m){ + LL sum = 0; + for(int i = 0; i = mid) sum += mid; + else sum += a[i]; + if(sum >= m * mid) return 1; + return 0; +} +int main() +{ LL n,m,sum,minx; + while(~scanf("%I64d%I64d",&n,&m)){ + sum = 0,minx = INF; + for(int i = 0; i < n; ++i){ + scanf("%d",&a[i]); + minx = min(minx,a[i]); + sum += a[i]; + } + LL L = minx,R = sum/m,mid,ans; + while(L <= R){ + mid = (R + L) >> 1; + if(judge(mid,n,m)){ + ans = mid; + L = mid + 1; + }else R = mid - 1; + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/3419_autoAC.cpp b/HDOJ/3419_autoAC.cpp new file mode 100644 index 0000000..f7ec237 --- /dev/null +++ b/HDOJ/3419_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +int a,b,c; +int ans; +int hash[10]; +int base[11],limit; +int t_a; +int t_b; +void judge() +{ + int i; + int t; + int temp[10]; + t=t_a*t_b; + if(limit<=t || t=base[b+1]) return ; + if(base[b]<=k) {t_b=k;judge();return ;} + for(i=1;i<10;i++) + { + if(hash[i]==0) + { + hash[i]=1; + DFS2(k*10+i); + hash[i]=0; + } + } +} +void DFS(int k) +{ + int i; + if(k>=base[a+1]) return; + if(base[a]<=k) + { + t_a=k; + DFS2(0); + return ; + } + for(i=1;i<10;i++) + { + if(hash[i]==0) + { + hash[i]=1; + DFS(k*10+i); + hash[i]=0; + } + } +} +int main() +{ + int i; + while(scanf("%d%d%d",&a,&b,&c),a||b||c) + { + if(a==0 || b==0 || c==0) {printf("0\n");continue;} + if(a+b-2>c) {printf("0\n");continue;} + base[1]=1; + for(i=2;i<=10;i++) base[i]=base[i-1]*10; + limit=base[c+1]; + ans=0; + memset(hash,0,sizeof(hash)); + DFS(0); + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3420_autoAC.cpp b/HDOJ/3420_autoAC.cpp new file mode 100644 index 0000000..cd97d89 --- /dev/null +++ b/HDOJ/3420_autoAC.cpp @@ -0,0 +1,18 @@ +#include +#include +int cmp(const void *a, const void *b){ + return *(int *)a - *(int *)b; +} +int main() { + int x[1001], n, i, j, tickets; + while(scanf("%d", &n) != EOF){ + for(i = 0; i < n; i++) + scanf("%d", x + i); + qsort(x, n, sizeof(x[0]), cmp); + tickets = 0; + for(i = 0; i < n; i++) + if(x[i] * (n - i) > tickets) + tickets = x[i] * (n - i); + printf("%d\n", tickets); + } +} diff --git a/HDOJ/3421_autoAC.cpp b/HDOJ/3421_autoAC.cpp new file mode 100644 index 0000000..67f49f5 --- /dev/null +++ b/HDOJ/3421_autoAC.cpp @@ -0,0 +1,41 @@ +#include +__int64 he; +int main() +{ + int t,n,i,ret,qian,j,dang; + scanf("%d",&t); + for(i=1;i<=t;) + { + he=0; + scanf("%d",&n); + qian=-1; + ret=0; + int ji=0; + for(j=1;j<=n;j++) + { + scanf("%d",&dang); + if(dang>0) he+=dang; + if(ji) + { + if(dang<0) + { + ji=0; + } + }else + { + if(dang==0) + { + }else if(dang>0) + { + ji=1; + ret++; + } + } + } + if(i!=1) + printf("\n"); + printf("Case %d:\n",i++); + printf("%d %I64d\n",ret,he); + } + return 0; +} diff --git a/HDOJ/3422_autoAC.cpp b/HDOJ/3422_autoAC.cpp new file mode 100644 index 0000000..d53fc0a --- /dev/null +++ b/HDOJ/3422_autoAC.cpp @@ -0,0 +1,10 @@ +#include +int main() +{ + long long i,j,n; + while(scanf("%I64d",&n)!=EOF) + { + printf("%I64d %I64d\n",4*n*n+6*n-1,2*n*n+2*n+1); + } + return 0; +} diff --git a/HDOJ/3423_autoAC.cpp b/HDOJ/3423_autoAC.cpp new file mode 100644 index 0000000..216cfd5 --- /dev/null +++ b/HDOJ/3423_autoAC.cpp @@ -0,0 +1,113 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define ll long long +#define L(rt) (rt<<1) +#define R(rt) (rt<<1|1) +using namespace std; +const int INF = 1e9; +const int maxn = 50005; +struct Edge{ + int v, w, next; +}et[maxn * 4]; +struct node{ + int u, v, l, id; +}ed[maxn * 10]; +int eh[maxn], fa[maxn], son[maxn], ans[maxn]; +ll dis1[maxn], dis2[maxn]; +int n, m, num; +ll Min; +void init(){ + memset(eh, -1, sizeof(eh)); + for(int i = 1; i <= n; i++) fa[i] = i; + num = 0; +} +void add(int u, int v, int w){ + Edge e = {v, w, eh[u]}; + et[num] = e; + eh[u] = num++; +} +int find(int x){ + return x == fa[x] ? x : fa[x] = find(fa[x]); +} +bool cmp(node a, node b){ + if(a.l != b.l) return a.l < b.l; + return a.id < b.id; +} +void dfs1(int u, int pre){ + son[u] = 1; + dis1[u] = 0; + for(int i = eh[u]; i != -1; i = et[i].next) + { + int v = et[i].v, w = et[i].w; + if(v == pre) continue; + dfs1(v, u); + son[u] += son[v]; + dis1[u] += son[v] * w + dis1[v]; + } +} +void dfs2(int u, int pre, int pedge){ + if(pre == -1) dis2[u] = 0; + else dis2[u] = dis2[pre] + dis1[pre] - dis1[u] - son[u] * pedge + ((ll)n - son[u]) * pedge; + for(int i = eh[u]; i != -1; i = et[i].next) + { + int v = et[i].v, w = et[i].w;; + if(v == pre) continue; + dfs2(v, u, w); + } + if(Min > dis1[u] + dis2[u]) Min = dis1[u] + dis2[u]; +} +int main() +{ + int t; + scanf("%d", &t); + while(t--) + { + scanf("%d%d", &n, &m); + init(); + for(int i = 0; i < m; i++) + { + scanf("%d%d%d", &ed[i].u, &ed[i].v, &ed[i].l); + ed[i].id = i; + } + sort(ed, ed + m, cmp); + ll ans1 = 0; + for(int i = 0; i < m; i++) + { + int u = ed[i].u, v = ed[i].v, l = ed[i].l; + int ru = find(u), rv = find(v); + if(ru == rv) continue; + fa[ru] = rv; + add(u, v, l); + add(v, u, l); + ans1 += l; + } + int cnt = 0; + for(int i = 1; i <= n; i++) + if(i == find(i)) cnt++; + if(cnt > 1) + { + printf("Poor mayor.\n"); + continue; + } + Min = 0x7fffffffffffffffLL; + dfs1(1, -1); + dfs2(1, -1, 0); + printf("%I64d\n", ans1); + cnt = 0; + for(int i = 1; i <= n; i++) + if(dis1[i] + dis2[i] == Min) + ans[cnt++] = i; + for(int i = 0; i < cnt - 1; i++) + printf("%d ", ans[i]); + printf("%d\n", ans[cnt - 1]); + printf("%I64d\n", 2 * Min); + } + return 0; +} diff --git a/HDOJ/3424_autoAC.cpp b/HDOJ/3424_autoAC.cpp new file mode 100644 index 0000000..224c946 --- /dev/null +++ b/HDOJ/3424_autoAC.cpp @@ -0,0 +1,17 @@ +#include +#include +using namespace std; +#define F(x) abs(x)>1e-6 +int main(){ + double x,y,a,b,s,f; + while(scanf("%lf%lf",&x,&y)&&(F(x+1.0)||F(y+1.0))){ + s=f=0; + while(scanf("%lf%lf",&a,&b)&&(F(a)||F(b))){ + if(b +#include +#include +#include +#include +#define eps 1e-8 +#define N 20010 +using namespace std; +int Sig(double a) +{ + return a<-eps?-1:a>eps; +} +struct Point +{ + double x,y; + Point(){} + Point(double x0,double y0):x(x0),y(y0){} + bool operator <(Point pt) + { + if(pt.x==x) + return y(Point pt) + { + if(pt.x==x) + return y>pt.y; + return x>pt.x; + } + bool operator ==(Point pt) + { + return !Sig(pt.x-x) && !Sig(pt.y-y); + } + Point operator +(Point pt) + { + return Point(x+pt.x,y+pt.y); + } + Point operator -(Point pt) + { + return Point(x-pt.x,y-pt.y); + } + Point operator *(double t) + { + return Point(x*t,y*t); + } + void Input() + { + scanf("%lf%lf",&x,&y); + } +}; +struct Range +{ + Point a,b; + Range(){} + Range(Point a0,Point b0):a(a0),b(b0){} + bool operator <(Range r) + { + if(a==r.a) + return b=0) + return ; + double h=sqrt(r*r-d*d); + Point tmp=Point(e.y-s.y,s.x-e.x); + Point o=Intersection(p,p+tmp,s,e); + Point p1,p2; + p1=o+(e-s)*(h/Dis(s,e)); + p2=o-(e-s)*(h/Dis(s,e)); + if(p2 +#include +#include +#include +using namespace std; +vector st; +int tag_type(const string& s) { + int cnt=0; + for(int i=0; i='a') || (s[i]>='0' && s[i]<='9'))) return 0; + } + if(s.size()-cnt==0) return 0; + if(s[0]=='/' && cnt == 1) return 2; + if(s[s.size()-1]=='/' && cnt == 1) return 3; + if(cnt == 0) return 1; + return 0; +} +bool hex(const string& s) { + if(s.size() <= 1 || s.size()%2==0) return false; + if(s[0] != 'x') return false; + for(int i=1; i='A') || (s[i]<='9' && s[i]>='0') || (s[i]<='f' && s[i]>='a')) ) return false; + return true; +} +bool bad_qoute(const string& s) { + return !(s=="lt" || s=="gt" || s=="amp" || hex(s)); +} +bool bad_txt(const string& s) { + string qoute; + for(int i=0; i') return true; + else if(s[i]>127 || s[i]<32) return true; + return false; +} +void get_l(stringstream& os, string& s, char del) { + char t; + while(!os.eof()) { + os >> t; + if(t==del) return; + s += t; + } +} +int main() { + string ln; + while(getline(cin, ln)) { + stringstream ss(ln); + st.clear(); + string s; + int inv=0; + while(!ss.eof()) { + s=""; + getline(ss,s,'<'); + if(bad_txt(s)) { + inv=1; + break; + } + if(ss.eof()) break; + s=""; + getline(ss,s,'>'); + if(ss.eof()) { + inv=4; + break; + } + int tty = tag_type(s); + if(tty==0) { + inv=2; + break; + } + else if(tty==1) st.push_back(s); + else if(tty==2) { + if(st.size()==0 || st.back() != s.substr(1)) { + inv=3; + break; + } + else st.pop_back(); + } + } + if(inv || st.size() > 0) puts("invalid"); + else puts("valid"); + } + return 0; +} diff --git a/HDOJ/3427_autoAC.cpp b/HDOJ/3427_autoAC.cpp new file mode 100644 index 0000000..e73c6cb --- /dev/null +++ b/HDOJ/3427_autoAC.cpp @@ -0,0 +1,69 @@ +#include +#include +#define NN 155 +char str[NN]; +int mark[NN][NN]; +int num[NN]; +char cha[NN]; +int dfs(int l, int r) +{ + int i, t; + if (l == r){ + if (num[l] > 1) + return 1; + else + return 0; + } + if (mark[l][r]>= 0) + return mark[l][r]; + char ch = cha[l]; + for (i = l + 1; i <= r; i++){ + if (cha[i] == ch){ + if (mark[l + 1][i - 1] = dfs(l + 1, i - 1)){ + t = mark[i][r]; + mark[i][r] = -1; + num[i] += num[l]; + mark[i][r] = dfs(i, r); + num[i] -= num[l]; + if (mark[i][r] == 1) + { + mark[i][r] = t; + return 1; + } + mark[i][r] = t; + } + } + } + if (num[l] > 1 && (mark[l + 1][r] = dfs(l + 1, r))) + return 1; + return 0; +} +int main() +{ + int len, time, index, i; + while (scanf("%s", str) != EOF){ + len = strlen(str); + if (len == 0){ + puts("solvable"); + continue; + } + time = 1; + index = 0; + for (i = 1; i <= len; i++){ + if (str[i] != str[i - 1]){ + cha[index] = str[i - 1]; + num[index] = time; + time = 1; + index++; + } + else + time++; + } + memset(mark, -1, sizeof(mark)); + if (dfs(0, index - 1)) + puts("solvable"); + else + puts("unsolvable"); + } + return 0; +} diff --git a/HDOJ/3429_autoAC.cpp b/HDOJ/3429_autoAC.cpp new file mode 100644 index 0000000..1c8604e --- /dev/null +++ b/HDOJ/3429_autoAC.cpp @@ -0,0 +1,195 @@ +#include +#include +#include +#include +#include +using namespace std; +#define i64 __int64 +class fraction +{ +private: + inline i64 Gcd (i64 x,i64 y) + { + return y==0?x:Gcd(y,x%y); + } + i64 Lcm (i64 x,i64 y) + { + x=x/Gcd(x,y)*y; + if(x<0) x=-x; + return x; + } +public: + i64 a,b; + fraction () {} + fraction (i64 x) + { + a=x; b=1; + } + fraction (i64 x,i64 y) + { + a=x; b=y; + Refresh(); + } + void Refresh () + { + if (b<0) b=-b,a=-a; + i64 k=Gcd(a,b); + if (k<0) k=-k; + a/=k; b/=k; + } + fraction Inverse () const + { + return fraction (b,a); + } + fraction operator + (fraction p) + { + fraction ans; + ans.b=Lcm(b,p.b); + ans.a=ans.b/b*a+ans.b/p.b*p.a; + ans.Refresh(); + return ans; + } + fraction operator - (fraction p) + { + fraction ans; + ans.b=Lcm(b,p.b); + ans.a=ans.b/b*a-ans.b/p.b*p.a; + ans.Refresh(); + return ans; + } + fraction operator * (fraction p) + { + fraction ans; + ans.a=a*p.a; + ans.b=b*p.b; + ans.Refresh(); + return ans; + } + fraction operator / (fraction p) + { + fraction ans; + ans.a=a*p.b; + ans.b=b*p.a; + ans.Refresh(); + return ans; + } + bool operator < (const fraction &p) const + { + return a*p.b (const fraction &p) const + { + return a*p.b>b*p.a; + } + bool operator == (const fraction &p) const + { + return a*p.b==b*p.a; + } + fraction operator | (fraction p) + { + fraction t1=fraction (b,a); + fraction t2=p.Inverse (); + t1=t1+t2; + return t1.Inverse(); + } + void print () + { + printf("%I64d/%I64d\n",a,b); + } +}; +string s; +int len; +fraction read (int &now) +{ + int fz=0,fm=0; + int i; + for (i=now;i +#include +const int N = 520; +int a[N + 5], b[N + 5], ta[N + 5], tb[N + 5]; +bool vis[N + 5]; +long long m[N + 5], c[N + 5]; +long long exgcd(long long a, long long b, long long &x, long long &y) { + if (!b) { + x = 1; + y = 0; + return a; + } + long long res = exgcd(b, a % b, y, x); + y -= a/b*x; + return res; +} +long long mod(long long a, long long b) { + long long res = a % b; + if (res < 0) res += b; + return res; +} +void solve(int n) { + memset(vis, false, sizeof(vis)); + int cnt = 0; + for (int i = 1; i <= n; ++i) + if (!vis[i]) { + int num = 0, t = i; + while (!vis[t]) { + vis[t] = true; + ta[++num] = t; + tb[num] = b[t]; + t = a[t]; + } + bool same = false; + for (int i = 1; i <= num; ++i) + if (tb[i] == ta[1]) { + same = true; + int j = i, k = 1; + do { + if (tb[j] != ta[k]) same = false; + j = j % num + 1; + k = k % num + 1; + } while (i != j); + t = i; + break; + } + if (!same) { + printf("-1\n"); + return; + } + m[++cnt] = num; + c[cnt] = (num - t + 1) % num; + } + n = cnt; + long long ans = c[1], LCM = m[1]; + for (int i = 2; i <= n; ++i) { + long long x, y, g = exgcd(LCM, m[i], x, y); + if ((c[i] - ans) % g) { + printf("-1\n"); + return; + } + ans = mod(ans + LCM*mod((c[i] - ans)/g*x, m[i]/g), LCM/g*m[i]); + LCM = LCM/g*m[i]; + } + printf("%I64d\n", ans); + return; +} +int main() { + int n; + while (scanf("%d", &n), n) { + for (int i = 1; i <= n; ++i) scanf("%d", &a[i]); + for (int i = 1; i <= n; ++i) scanf("%d", &b[i]); + solve(n); + } + return 0; +} diff --git a/HDOJ/3432_autoAC.cpp b/HDOJ/3432_autoAC.cpp new file mode 100644 index 0000000..6f079da --- /dev/null +++ b/HDOJ/3432_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +using namespace std; +const double eps=1e-6; +int dcmp(double x) +{ + if(fabs(x)height) + { + tmp-=(height-prey)*d1/2; + y=height; + x=width-tmp*2/y; + } + } + else if(dcmp(prex)==0) + { + x=0; + y=prey-2*tmp/door; + } + } + else + { + y=height; + x=prex-tmp*2/height; + if(x<0) + { + tmp=tmp-prex*prey/2; + x=0; + y=height-tmp*2/door; + } + } + prex=x; + prey=y; + printf("%.3lf %.3lf ",x,y); + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/3433_autoAC.cpp b/HDOJ/3433_autoAC.cpp new file mode 100644 index 0000000..4632a48 --- /dev/null +++ b/HDOJ/3433_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +using namespace std; +int dp[55][205], a[205], b[205]; +int _, n, x, y, kase = 0; +bool check(int t) +{ + memset(dp, -1, sizeof(dp)); + dp[0][0] = 0; + for(int i = 1; i <= n; ++i) + { + if(dp[i][x] >= y) return true; + for(int j = 0; j <= x; ++j) + { + if(dp[i - 1][j] != -1) + { + int temp = min(t/a[i], x-j); + for(int k = 0; k <= temp; ++k) + { + int t1 = (t - a[i] * k) / b[i]; + dp[i][j + k] = max(dp[i][j + k], dp[i - 1][j] + t1); + } + } + } + } + if(dp[n][x] >= y) return true; + return false; +} +int main(void) +{ + scanf("%d", &_); + while(_--) + { + scanf("%d%d%d", &n, &x, &y); + for(int i = 1; i <= n; ++i) + scanf("%d%d", &a[i], &b[i]); + int l = 0, r = a[1] * x + b[1] * y; + int ans = r; + while(l <= r) + { + int mid = (l + r) >> 1; + if(check(mid)) + { + ans = mid; + r = mid - 1; + } + else l = mid + 1; + } + printf("Case %d: %d\n", ++kase, ans); + } + return 0; +} diff --git a/HDOJ/3434_autoAC.cpp b/HDOJ/3434_autoAC.cpp new file mode 100644 index 0000000..3741b92 --- /dev/null +++ b/HDOJ/3434_autoAC.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +using namespace std; +#define L 1000100 +int a[L],b[L],p[L]; +long long min(long long x,long long y) +{ + if (x +#include +#include +using namespace std; +const int inf=1<<28; +int g[1005][1005]; +int lx[1005],ly[1005]; +bool sx[1005],sy[1005]; +int link[1005],n; +vector q[1010]; +int min(int a,int b) +{ + if(a +#include +#include +#define MAXD 100010 +int N, Q, T, node, tx[MAXD], begin[MAXD], end[MAXD], nodep[MAXD]; +int num[2 * MAXD], size[2 * MAXD], left[2 * MAXD], right[2 * MAXD], pre[2 * MAXD], key[2 * MAXD]; +char b[MAXD][10]; +int ob[MAXD]; +int cmp(const void *_p, const void *_q) +{ + int *p = (int *)_p, *q = (int *)_q; + return *p - *q; +} +void update(int cur) +{ + size[cur] = size[left[cur]] + size[right[cur]] + num[cur]; +} +void newnode(int &cur, int k) +{ + cur = ++ node; + size[cur] = num[cur] = end[k] - begin[k] + 1; + key[cur] = k; + nodep[k] = cur; + left[cur] = right[cur] = 0; +} +void build(int &cur, int x, int y, int p) +{ + int mid = (x + y) / 2; + newnode(cur, mid); + pre[cur] = p; + if(x == y) + return ; + if(x < mid) + build(left[cur], x, mid - 1, cur); + if(mid < y) + build(right[cur], mid + 1, y, cur); + update(cur); +} +void init() +{ + int i, j, k; + scanf("%d%d", &N, &Q); + k = 0; + tx[k ++] = 0; + for(i = 0; i < Q; i ++) + { + scanf("%s%d", b[i], &ob[i]); + if(b[i][0] == 'T' || b[i][0] == 'Q') + tx[k ++] = ob[i]; + } + tx[k ++] = N; + qsort(tx, k, sizeof(tx[0]), cmp); + N = 0; + for(i = 1; i < k; i ++) + if(tx[i] != tx[i - 1]) + { + if(tx[i] - tx[i - 1] > 1) + { + begin[N] = tx[i - 1] + 1, end[N] = tx[i] - 1; + ++ N; + } + begin[N] = end[N] = tx[i]; + ++ N; + } + T = node = left[0] = right[0] = size[0] = num[0] = 0; + build(T, 0, N - 1, 0); +} +void leftrotate(int x) +{ + int y = right[x], p = pre[x]; + right[x] = left[y]; + if(right[x]) + pre[right[x]] = x; + left[y] = x; + pre[x] = y; + pre[y] = p; + if(p == 0) + T = y; + else + right[p] == x ? right[p] = y : left[p] = y; + update(x); +} +void rightrotate(int x) +{ + int y = left[x], p = pre[x]; + left[x] = right[y]; + if(left[x]) + pre[left[x]] = x; + right[y] = x; + pre[x] = y; + pre[y] = p; + if(p == 0) + T = y; + else + right[p] == x ? right[p] = y : left[p] = y; + update(x); +} +void splay(int x, int goal) +{ + int y, z; + for(;;) + { + if((y = pre[x]) == goal) + break; + if((z = pre[y]) == goal) + right[y] == x ? leftrotate(y) : rightrotate(y); + else + { + if(right[z] == y) + { + if(right[y] == x) + leftrotate(z), leftrotate(y); + else + rightrotate(y), leftrotate(z); + } + else + { + if(left[y] == x) + rightrotate(z), rightrotate(y); + else + leftrotate(y), rightrotate(z); + } + } + } + update(x); +} +int BS(int x) +{ + int max, mid, min; + min = 0, max = N; + for(;;) + { + mid = (max + min) / 2; + if(mid == min) + break; + if(begin[mid] <= x) + min = mid; + else + max = mid; + } + return mid; +} +int Delete(int &cur, int p) +{ + int k; + if(cur == T || right[cur] == 0) + { + if(cur == T) + { + k = Delete(left[cur], cur); + left[k] = left[T], right[k] = right[T]; + if(left[k]) + pre[left[k]] = k; + if(right[k]) + pre[right[k]] = k; + T = k; + pre[T] = 0; + update(T); + } + else + { + k = cur; + if(left[k]) + pre[left[k]] = p; + cur = left[k]; + } + return k; + } + else + { + k = Delete(right[cur], cur); + update(cur); + return k; + } +} +void Insert(int &cur, int k, int p) +{ + if(cur == 0) + { + newnode(cur, k); + pre[cur] = p; + return ; + } + Insert(left[cur], k, cur); + update(cur); +} +void Top(int x) +{ + int k, cur; + k = BS(x); + cur = nodep[k]; + splay(cur, 0); + if(left[T] == 0 || right[T] == 0) + { + T = left[T] + right[T]; + pre[T] = 0; + } + else + Delete(T, 0); + Insert(T, k, 0); + splay(node, 0); +} +void Query(int x) +{ + int k, cur; + k = BS(x); + cur = nodep[k]; + splay(cur, 0); + printf("%d\n", size[left[cur]] + 1); +} +int Search(int cur, int x) +{ + int ls = left[cur], rs = right[cur], k = key[cur]; + if(x <= size[ls]) + return Search(left[cur], x); + else if(x <= size[ls] + num[cur]) + return begin[k] + (x - size[ls]) - 1; + else + return Search(right[cur], x - size[ls] - num[cur]); +} +void Rank(int x) +{ + printf("%d\n", Search(T, x)); +} +void solve() +{ + int i, j, k; + for(i = 0; i < Q; i ++) + { + if(b[i][0] == 'T') + Top(ob[i]); + else if(b[i][0] == 'Q') + Query(ob[i]); + else + Rank(ob[i]); + } +} +int main() +{ + int t, tt; + scanf("%d", &t); + for(tt = 0; tt < t; tt ++) + { + init(); + printf("Case %d:\n", tt + 1); + solve(); + } + return 0; +} diff --git a/HDOJ/3437_autoAC.cpp b/HDOJ/3437_autoAC.cpp new file mode 100644 index 0000000..3060353 --- /dev/null +++ b/HDOJ/3437_autoAC.cpp @@ -0,0 +1,117 @@ +#include +#include +#include +#define zero(x) if(dcmp(x)==0)x=0 +#define cross(p0,p1,p2) ((p1.x-p0.x)*(p2.y-p0.y)-(p1.y-p0.y)*(p2.x-p0.x)) +#define dot(p0,p1,p2) ((p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y)) +#define luoti(h) (sqrt(2*(h)/9.18)) +#define ponseg(p0,p1,p2) (dcmp(cross(p0,p1,p2))==0&&dcmp(dot(p0,p1,p2))<=0) +using namespace std; +const double eps=1e-4; +const double inf=1e10; +struct point{ + double x,y; +}; +struct wx{ + double z,k; + int n,type; + point p[11]; +}rec[11]; +double cmp(wx a,wx b){ + return a.z>b.z; +} +int dcmp(double x){ + return (x>eps)-(x<-eps); +} +bool reach(double vx,double vy,double x,double y,double z,wx pol){ + double sum=luoti(z-pol.z); + point p; + p.x=x+sum*vx; + p.y=y+sum*vy; + for(int i=0;iz){ + i--; + n--; + } + } + if(z<0){ + puts("Forever!"); + continue; + } + sort(rec,rec+n,cmp); + double times=0; + for(int i=0;times>=0&&i +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxn=100005; +ll n,k,m; +ll f1[2*maxn],f2[maxn],c[maxn],mul[maxn],num[maxn],tot; +ll cp() +{ + f1[0]=1%m;f1[1]=0; + ll i; + for(i=2;i<=2*m;++i) + f1[i]=(((f1[i-1]+f1[i-2])%m)*(i-1))%m; + return f1[(n-k)%(2*m)]; +} +void prem() +{ + ll i,mm; + mm=m; + tot=0; + for(i=2;i*i<=mm;++i) + { + if(mm%i==0) + { + c[tot]=i;mul[tot]=1;num[tot]=0; + while(mm%i==0) + { + mul[tot]*=i; + num[tot]++; + mm/=i; + } + tot++; + } + } + if(mm!=1) + { + c[tot]=mm;mul[tot]=mm;num[tot]=1; + tot++; + } +} +ll quickpow(ll a,ll b,ll c) +{ + ll ret=1; + while(b) + { + if(b&1) + { + (ret*=a)%=c; + } + (a*=a)%=c; + b>>=1; + } + return ret%c; +} +void ex_gcd(ll a,ll b,ll &x,ll &y) +{ + if(b==0) + { + x=1;y=0; + return ; + } + ex_gcd(b,a%b,x,y); + ll t=x; + x=y; + y=t-(a/b)*y; +} +ll count(ll a,ll p) +{ + if(a=nm) + return 0; + ll ret=quickpow(p,t1,mp); + ll i,x,y; + f2[0]=1; + for(i=1;i<=mp;++i) + { + f2[i]=f2[i-1]; + if(i%p!=0) + f2[i]*=i; + f2[i]%=mp; + } + ex_gcd(count2(k,p,mp)*count2(n-k,p,mp),mp,x,y); + (ret*=x)%=mp; + (ret*=count2(n,p,mp))%=mp; + return ret; +} +ll work() +{ + ll i,ret=0,tmp,x,y; + prem(); + for(i=0;i +#include +#include +#include +#include +int T,n,d,dis[1010],nxt[1010],h,in[1010],cnt[1010]; +const int inf=1000000000; +using namespace std; +struct node +{ + int id,h; + node(int a=0,int b=0):id(a),h(b){} + friend bool operator < (node a,node b) + { + return a.hvt[1010]; +node a[1010]; +int spfa(int x,int y) +{ + fill(dis,dis+1+n,inf); + memset(in,0,sizeof(in)); + dis[x]=0; + in[x]=1; + memset(cnt,0,sizeof(cnt)); + cnt[x]=1; + queueq; + q.push(x); + while(!q.empty()) + { + int s=q.front(); + q.pop(); + in[s]=0; + for(int i=0;idis[s]+l) + { + dis[y]=dis[s]+l; + if(!in[y]) + { + q.push(y); + cnt[y]++; + if(cnt[y]>n)return -1; + in[y]=1; + } + } + } + } + return dis[y]; +} +int main() +{ + scanf("%d",&T); + for(int cas=1;cas<=T;cas++) + { + scanf("%d%d",&n,&d); + for(int i=1;i<=n;i++) + vt[i].clear(); + for(int i=1;i<=n;i++) + { + scanf("%d",&h); + a[i]=node(i,h); + } + sort(a+1,a+1+n); + for(int i=1;i +#include +#include +#define MOD 1000000007 +#define MAXD 40010 +using namespace std; +int isprime[MAXD], prime[MAXD], P, p[MAXD], pn; +long long A, C, K, ANS, T; +void exgcd(long long a, long long b, long long &x, long long &y) +{ + if(b == 0) + x = 1, y = 0; + else + exgcd(b, a % b, y, x), y -= x * (a / b); +} +long long powmod(long long a, long long n) +{ + long long ans = 1; + while(n) + { + if(n & 1) + ans = ans * a % MOD; + n >>= 1; + a = a * a % MOD; + } + return ans; +} +void prepare() +{ + int i, j, k = 40000; + memset(isprime, -1, sizeof(isprime)); + P = 0; + for(i = 2; i <= k; i ++) + if(isprime[i]) + { + prime[P ++] = i; + for(j = i * i; j <= k; j += i) + isprime[j] = 0; + } +} +long long block(long long n, long long c) +{ + long long ans, x, y; + ans = powmod(c, n * n); + ans = (ans + 2 * powmod(c, n * n / 4 + (n & 1))) % MOD; + ans = (ans + powmod(c, n * n / 2 + (n & 1))) % MOD; + exgcd(4, MOD, x, y); + x = (x % MOD + MOD) % MOD; + ans = ans * x % MOD; + return ans; +} +long long euler(long long n) +{ + int i; + long long ans = n; + for(i = 0; i < pn; i ++) + if(n % p[i] == 0) + ans = ans / p[i] * (p[i] - 1); + return ans; +} +long long prepareBK() +{ + int i, j, nx, ny, x, y, cnt; + long long N = 1; + nx = x = A - 1, ny = y = A + 1; + pn = 0; + for(i = 0; i < P && prime[i] * prime[i] <= ny; i ++) + { + cnt = 0; + if(x % prime[i] == 0 || y % prime[i] == 0) + p[pn ++] = prime[i]; + while(x % prime[i] == 0) + ++ cnt, x /= prime[i]; + while(y % prime[i] == 0) + ++ cnt, y /= prime[i]; + for(j = 0, cnt /= 2; j < cnt; j ++) + N *= prime[i]; + } + if(x > y) + i = x, x = y, y = i; + if(x > 1) + p[pn ++] = x; + if(y > 1) + p[pn ++] = y; + if(x == y) + N *= x; + return N; +} +void dfs(int cur, long long R, long long x, long long &c) +{ + int i, cnt = 0; + long long t = 1; + if(cur == pn) + { + long long ans, n, x, y; + n = euler(K / R) % MOD; + T = (T + n * powmod(c, R)) % MOD; + return ; + } + while(x % p[cur] == 0) + x /= p[cur], ++ cnt; + for(i = 0; i <= cnt; i ++) + { + dfs(cur + 1, R * t, x, c); + t *= p[cur]; + } +} +void findB(int cur, long long B, long long x) +{ + int i, cnt = 0; + long long t = 1; + if(cur == pn) + { + long long n, x, y, c; + c = block(B, C); + K = (A * A - 1) / (B * B); + T = 0; + dfs(0, 1, K, c); + exgcd(K, MOD, x, y); + x = (x % MOD + MOD) % MOD; + T = (T * x) % MOD; + ANS = (ANS + T * C) % MOD; + return ; + } + while(x % p[cur] == 0) + ++ cnt, x /= p[cur]; + for(i = 0; i <= cnt; i ++) + { + findB(cur + 1, B * t, x); + t *= p[cur]; + } +} +void solve() +{ + ANS = 0; + findB(0, 1, prepareBK()); + printf("%I64d\n", ANS); +} +int main() +{ + int t, tt; + prepare(); + scanf("%d", &t); + for(tt = 0; tt < t; tt ++) + { + printf("Case %d: ", tt + 1); + scanf("%I64d%I64d", &A, &C); + if(A == 1) + printf("%I64d\n", C); + else + solve(); + } + return 0; +} diff --git a/HDOJ/3442_autoAC.cpp b/HDOJ/3442_autoAC.cpp new file mode 100644 index 0000000..b1b8a30 --- /dev/null +++ b/HDOJ/3442_autoAC.cpp @@ -0,0 +1,140 @@ +#include +#include +#include + using namespace std; + struct node +{ + int damage,x,y; + int mark[5]; + bool operator <(const node &a)const + { + return a.damage qu; + cur.x=x;cur.y=y;cur.damage =0; + queue q; + int i,j; + for(i=0;i<5;i++) + { + cur.mark[i]=0; + } + qu.push(cur); + while(!qu.empty ()) + { + cur=qu.top (); + qu.pop(); + if(a[cur.x][cur.y]=='!') + { + tag=1; + return ; + } + for(i=0;i<4;i++) + { + ne.x=cur.x+dir[i][0]; + ne.y=cur.y+dir[i][1]; + if(ne.x>=1&&ne.x<=n&&ne.y>=1&&ne.y<=m&&a[ne.x][ne.y]!='#'&&a[ne.x][ne.y]!='A'&&a[ne.x][ne.y]!='B'&&a[ne.x][ne.y]!='D'&&a[ne.x][ne.y]!='E') + { + ne.damage =cur.damage ; + for(j=0;j<5;j++) + { + ne.mark[j]=cur.mark[j]; + } + if(a[ne.x][ne.y]=='C' && cur.mark[2]==0) + { + ne.damage +=3; + ne.mark[2]=1; + } + memset(mark1,0,sizeof(mark1)); + while(!q.empty ()) + q.pop (); + cur1.x=ne.x; + cur1.y=ne.y; + cur1.t=0; + q.push(cur1); + while(!q.empty ()) + { + cur1=q.front (); + q.pop(); + if(cur1.t>3) + break; + if(ne.mark[0]==0 && cur1.t<=2 && a[cur1.x][cur1.y]=='A') + { + ne.damage+=1; + ne.mark[0]=1; + } + if(ne.mark[1]==0 && cur1.t<=3 && a[cur1.x][cur1.y]=='B') + { + ne.damage +=2; + ne.mark[1]=1; + } + if(ne.mark[3]==0 && cur1.t<=2&&a[cur1.x][cur1.y]=='D') + { + ne.damage +=4; + ne.mark[3]=1; + } + if(ne.mark[4]==0 && cur1.t<=1&&a[cur1.x][cur1.y]=='E') + { + ne.damage +=5; + ne.mark [4]=1; + } + for(j=0;j<=4;j++) + { + next1.x=cur1.x+dir[j][0]; + next1.y=cur1.y+dir[j][1]; + if(next1.x>=1&&next1.x<=n&&next1.y>=1&&next1.y<=m&&!mark1[next1.x][next1.y]) + { + mark1[next1.x][next1.y]=1; + next1.t=cur1.t+1; + q.push(next1); + } + } + } + if(mark[ne.x][ne.y]>ne.damage) + { + mark[ne.x][ne.y]=ne.damage; + qu.push(ne); + } + } + } + } +} +int main() +{ + int t,i,j,sx,sy,count=0; + scanf("%d",&t); + while(t--) + { + count++;tag=0; + scanf("%d%d",&n,&m); + for(i=1;i<=n;i++) + { + getchar(); + for(j=1;j<=m;j++) + { + scanf("%c",&a[i][j]); + mark[i][j]=0xfffffff; + if(a[i][j]=='$') + { + sx=i;sy=j; + } + } + } + bfs(sx,sy); + if(tag) + printf("Case %d: %d\n",count,cur.damage ); + else + printf("Case %d: %d\n",count,-1); + } + return 0; +} diff --git a/HDOJ/3443_autoAC.cpp b/HDOJ/3443_autoAC.cpp new file mode 100644 index 0000000..046c3cb --- /dev/null +++ b/HDOJ/3443_autoAC.cpp @@ -0,0 +1,14 @@ +#include +#define LL __int64 +int main() +{ + LL x,k; + while(scanf("%I64d",&x)&&x){ + k=1; + while(k +#include +#include +#include +#include +using namespace std; +const int N=250; +int n; +int head; +int tail; +int Start; +int Finish; +int link[N]; +int Father[N]; +int Base[N]; +int Q[N]; +bool mark[N]; +bool mat[N][N]; +bool InBlossom[N]; +bool in_Queue[N]; +void BlossomContract(int x,int y){ + memset(mark,0,sizeof(mark)); + memset(InBlossom,0,sizeof(InBlossom)); + #define pre Father[link[i]] + int lca,i; + for (i=x;i;i=pre) {i=Base[i]; mark[i]=true; } + for (i=y;i;i=pre) {i=Base[i]; if (mark[i]) {lca=i; break;} } + for (i=x;Base[i]!=lca;i=pre){ + if (Base[pre]!=lca) Father[pre]=link[i]; + InBlossom[Base[i]]=true; + InBlossom[Base[link[i]]]=true; + } + for (i=y;Base[i]!=lca;i=pre){ + if (Base[pre]!=lca) Father[pre]=link[i]; + InBlossom[Base[i]]=true; + InBlossom[Base[link[i]]]=true; + } + #undef pre + if (Base[x]!=lca) Father[x]=y; + if (Base[y]!=lca) Father[y]=x; + for (i=1;i<=n;i++) + if (InBlossom[Base[i]]){ + Base[i]=lca; + if (!in_Queue[i]){ + Q[++tail]=i; + in_Queue[i]=true; + } + } +} +void Change(){ + int x,y,z; + z=Finish; + while (z){ + y=Father[z]; + x=link[y]; + link[y]=z; + link[z]=y; + z=x; + } +} +void FindAugmentPath(){ + memset(Father,0,sizeof(Father)); + memset(in_Queue,0,sizeof(in_Queue)); + for (int i=1;i<=n;i++) Base[i]=i; + head=0; tail=1; + Q[1]=Start; + in_Queue[Start]=1; + while (head!=tail){ + int x=Q[++head]; + for (int y=1;y<=n;y++) + if (mat[x][y] && Base[x]!=Base[y] && link[x]!=y) + if ( Start==y || link[y] && Father[link[y]] ) + BlossomContract(x,y); + else if (!Father[y]){ + Father[y]=x; + if (link[y]){ + Q[++tail]=link[y]; + in_Queue[link[y]]=true; + } + else{ + Finish=y; + Change(); + return; + } + } + } +} +void Edmonds(){ + memset(link,0,sizeof(link)); + for (Start=1;Start<=n;Start++) + if (link[Start]==0) + FindAugmentPath(); +} +int MaxMatch() +{ + Edmonds(); + int cnt=0; + for (int i=1;i<=n;i++) + if (link[i]) cnt++; + return cnt; +} +void output(){ + memset(mark,0,sizeof(mark)); + int cnt=0; + for (int i=1;i<=n;i++) + if (link[i]) cnt++; + printf("%d\n",cnt); + for (int i=1;i<=n;i++) + if (!mark[i] && link[i]){ + mark[i]=true; + mark[link[i]]=true; + printf("%d %d\n",i,link[i]); + } +} +char str[50][50]; +const int dx[]={-1,-1,-1,1,1,1,0,0,2,-2,2,-2,2,-2,2,-2,1,-1,-1,1}; +const int dy[]={-1,1,0,0,1,-1,-1,1,2,2,-2,-2,1,-1,-1,1,2,-2,2,-2}; +int main() +{ + int ci,pl=1;scanf("%d",&ci); + while(ci--) + { + int r,c;scanf("%d%d",&r,&c); + n=r*c; + for(int i=0;i=0&&x=0&&y=0&&x=0&&y +#include +#include +#include +using namespace std; +int n,m,k; +int wi[60]; +int cnt; +void dfs(int id,int num,int weight) +{ + cnt=max(cnt,weight); + if(id==k) return ; + dfs(id+1,num,weight); + if(weight+wi[id]<=m&&num+1<=n) dfs(id+1,num+1,weight+wi[id]); +} +int main() +{ + while(scanf("%d%d",&n,&m)==2) + { + scanf("%d",&k); + int tsum; + for(int i=0;i=k-n;i--) tsum+=wi[i]; + if(wi[0]>m) tsum=0; + if(tsum<=m) + { + printf("%d\n",tsum); + continue; + } + cnt=0; + dfs(0,0,0); + printf("%d\n",cnt); + } + return 0; +} diff --git a/HDOJ/3449_autoAC.cpp b/HDOJ/3449_autoAC.cpp new file mode 100644 index 0000000..9678bbb --- /dev/null +++ b/HDOJ/3449_autoAC.cpp @@ -0,0 +1,30 @@ +#include +#include +#include +using namespace std; +const int Ni = 55; +const int Mi = 100005; +int dp[Ni][Mi]; +int main() +{ + int n,m,tv,i,j,k,pi,c,w; + memset(dp[0],0,sizeof(dp[0])); + while(~scanf("%d%d",&n,&tv)) + { + for(i=1;i<=n;i++) + { + scanf("%d%d",&pi,&m); + for(j=0;j=pi;j--) dp[i][j]=dp[i-1][j-pi]; + for(k=0;k=c;j--) if(dp[i][j-c]!=-1) + dp[i][j]=max(dp[i][j],dp[i][j-c]+w); + } + for(j=tv;j>=0;j--) dp[i][j]=max(dp[i][j],dp[i-1][j]); + } + printf("%d\n",dp[n][tv]); + } + return 0; +} diff --git a/HDOJ/3450_autoAC.cpp b/HDOJ/3450_autoAC.cpp new file mode 100644 index 0000000..b7d6263 --- /dev/null +++ b/HDOJ/3450_autoAC.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +#include +using namespace std; +const int maxn=100002; +const int oo=1000000000; +const int mod=9901; +int c[maxn],n,d,b[maxn],a[maxn]; +void add(int x,int val) +{ + while(x<=maxn) + { + c[x]+=val; + c[x]%=mod; + x+=(x&-x); + } +} +int sum(int x) +{ + int s=0; + while(x>0) + { + s+=c[x]; + s%=mod; + x-=(x&-x); + } + return s; +} +int main() +{ + int i,id,up,down,val,ans; + while(~scanf("%d%d",&n,&d)) + { + mapflag; + map::iterator it; + flag[0]=0; + memset(c,0,sizeof(c)); + for(i=0; isecond; + it=flag.upper_bound(a[i]+d); + up=it->second-1; + it=flag.lower_bound(a[i]-d); + down=it->second; + val=sum(up)-sum(down-1)+1; + val=(val%mod+mod)%mod; + add(id,val); + } + ans=sum(cnt); + ans=((ans-n)%mod+mod)%mod; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3451_autoAC.cpp b/HDOJ/3451_autoAC.cpp new file mode 100644 index 0000000..4d33833 --- /dev/null +++ b/HDOJ/3451_autoAC.cpp @@ -0,0 +1,121 @@ +#include +#include +#include +#include +using namespace std; +int board[105][105]; +int sep[105][105]; +int n,m,l; +struct bnode +{ + int x,y,d,time; +}; +int dir[4][2]={0,-1,0,1,-1,0,1,0}; +void bfs(int x,int y) +{ + queue sav; + while(!sav.empty())sav.pop(); + board[x][y]++; + if(board[x][y]>l){ + board[x][y]=0; + sep[x][y]=0; + for(int i=0;i<4;++i) + { + bnode tmp; + tmp.x=x+dir[i][0]; + tmp.y=y+dir[i][1]; + tmp.d=i; + tmp.time=1; + if(tmp.x<=n&&tmp.x>=1&&tmp.y<=m&&tmp.y>=1) + sav.push(tmp); + } + } + while(!sav.empty()) + { + bnode now=sav.front(); + sav.pop(); + if(board[now.x][now.y]=1&&tmp.y<=m&&tmp.y>=1) + sav.push(tmp); + } + } + else if(board[now.x][now.y]==0) + { + if(sep[now.x][now.y]!=now.time) + { + bnode tmp; + tmp.x=now.x+dir[now.d][0]; + tmp.y=now.y+dir[now.d][1]; + tmp.d=now.d; + tmp.time=now.time+1; + if(tmp.x<=n&&tmp.x>=1&&tmp.y<=m&&tmp.y>=1) + sav.push(tmp); + } + } + } +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + memset(sep,0,sizeof(sep)); + scanf("%d%d%d",&n,&m,&l); + bool flag=false; + for(int i=1;i<=n;++i) + { + for(int j=1;j<=m;++j) + { + scanf("%d",&board[i][j]); + if(board[i][j])flag=true; + } + } + int q; + scanf("%d",&q); + while(q--) + { + int x,y; + scanf("%d%d",&x,&y); + if(!flag)continue; + bfs(x,y); + flag=false; + for(int i=1;i<=n;++i) + { + if(flag)break; + for(int j=1;j<=m;++j) + { + if(board[i][j]){flag=true;break;} + } + } + } + if(!flag)printf("YES\n"); + else + { + printf("NO\n"); + for(int i=1;i<=n;++i) + { + for(int j=1;j<=m;++j) + { + printf("%d ",board[i][j]); + } + printf("\n"); + } + } + } + return 0; +} diff --git a/HDOJ/3452_autoAC.cpp b/HDOJ/3452_autoAC.cpp new file mode 100644 index 0000000..a6b3fe7 --- /dev/null +++ b/HDOJ/3452_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +using namespace std; +#define N 2005 +#define INF 0x7fffffff +int dp[N]; +int tmp=0; +int e, ne[N], v[N], w[N],adj[N]; +void add(int x, int y, int z) +{ + v[e] = y, w[e] = z; + ne[e] = adj[x], adj[x] = e ++; +} +void dfs(int cur, int fa) +{ + int i, flag = 0; + dp[cur] = 0; + for(i = adj[cur]; i != -1; i = ne[i]) + if(v[i] != fa) + { + flag = 1; + dfs(v[i], cur); + dp[cur] += min(w[i], dp[v[i]]); + } + if(flag == 0) dp[cur] = INF; +} +int main() +{ + int n,r,a,b,c; + while(scanf("%d%d",&n,&r)!=EOF) + { + if(n==0 && r==0) + break; + memset(adj,-1,sizeof(adj)); + for(int i=1; i +#include +#include +#include +#include +typedef long long LL; +using namespace std; +const int INF=0x3f3f3f; +const int maxn=1e5+100; +int dp[maxn][15]; +int ha[10*maxn]; +int num[maxn],n; +int main() +{ + while(~scanf("%d",&n)&&n) + { + memset(dp,INF,sizeof(dp)); + memset(ha,-1,sizeof(ha)); + for(int i=1;i<=n;i++) + { + scanf("%d",&num[i]); + ha[num[i]]=i; + } + dp[2][num[2]-num[1]]=0; + for(int i=2;i<=n;i++) + { + for(int j=1;j<=10;j++) + { + if(j>num[i]) break; + for(int k=j+1;k<=10;k++) + { + int tt=num[i]-j; + if(ha[tt]>=0) + dp[i][j]=min(dp[ha[tt]][k-j]+1,dp[i][j]); + } + } + } + int ans=INF; + for(int i=1;i<=10;i++) + ans=min(ans,dp[n][i]); + if(ans +#include +using namespace std; +string word; +string buf; +int main(){ + bool sign=true; + while(cin>>word){ + if(sign){ + buf+="Forty-two"; + sign=false; + } + if(word[word.size()-1]=='.'){ + buf.clear(); + sign=true; + continue; + } + if(word[word.size()-1]=='?'){ + buf+=" "; + buf+=word; + buf[buf.size()-1]='.'; + cout< +#include +#include +#include +#define Max(a,b) a>b?a:b +using namespace std; +int n; +int dp[1111],map[1111][1111]; +struct node +{ + int x1,x2,y1,y2; +}s[1111]; +int dfs(int x) +{ + int i,j,k,l; + if(dp[x])return dp[x]; + for(i=0;i +#include +using namespace std; +#define N 200020 +struct Node { + int x,y,lt,id ; +}point[N]; +int n,len,maxlp[N],by[N]; +int cmp(Node a,Node b) { + if(a.x != b.x) + return a.x < b.x ; + if(a.y == b.y) + return a.lt > b.lt ; + return a.y < b.y ; +} +int find(int len,int _y) { + int mid, left = 1, right = len ; + while(left <= right) { + mid = (left+right) >> 1 ; + if(by[mid] >= _y) + right = mid-1 ; + else left = mid+1 ; + } + return left ; +} +int main() { + while(scanf("%d",&n) && n) { + for(int i=0;i len) by[++len] = point[i].y ; + else by[tmp] = min(by[tmp],point[i].y) ; + } + } + printf("%d\n",len); + } + return 0; +} diff --git a/HDOJ/3459_autoAC.cpp b/HDOJ/3459_autoAC.cpp new file mode 100644 index 0000000..256e053 --- /dev/null +++ b/HDOJ/3459_autoAC.cpp @@ -0,0 +1,202 @@ +#include +#include +#include +using namespace std; +struct node +{ + int x,y; +} cube[10][10],side[10][10]; +char color[10],rubik[10][10]; +int ans[1000]; +int flag,step; +void init() +{ + cube[0][0].x=3,cube[0][0].y=2; + cube[0][1].x=3,cube[0][1].y=1; + cube[0][2].x=4,cube[0][2].y=2; + cube[1][0].x=3,cube[1][0].y=3; + cube[1][1].x=3,cube[1][1].y=4; + cube[1][2].x=4,cube[1][2].y=3; + cube[2][0].x=2,cube[2][0].y=2; + cube[2][1].x=2,cube[2][1].y=1; + cube[2][2].x=1,cube[2][2].y=2; + cube[3][0].x=2,cube[3][0].y=3; + cube[3][1].x=1,cube[3][1].y=3; + cube[3][2].x=2,cube[3][2].y=4; + cube[4][0].x=3,cube[4][0].y=0; + cube[4][1].x=5,cube[4][1].y=2; + cube[4][2].x=3,cube[4][2].y=7; + cube[5][0].x=5,cube[5][0].y=3; + cube[5][1].x=3,cube[5][1].y=5; + cube[5][2].x=3,cube[5][2].y=6; + cube[6][0].x=0,cube[6][0].y=2; + cube[6][1].x=2,cube[6][1].y=7; + cube[6][2].x=2,cube[6][2].y=0; + cube[7][0].x=0,cube[7][0].y=3; + cube[7][1].x=2,cube[7][1].y=5; + cube[7][2].x=2,cube[7][2].y=6; + side[0][0].x=0,side[0][0].y=2; + side[0][1].x=0,side[0][1].y=3; + side[0][2].x=1,side[0][2].y=2; + side[0][3].x=1,side[0][3].y=3; + side[1][0].x=2,side[1][0].y=0; + side[1][1].x=2,side[1][1].y=1; + side[1][2].x=3,side[1][2].y=0; + side[1][3].x=3,side[1][3].y=1; + side[2][0].x=2,side[2][0].y=2; + side[2][1].x=2,side[2][1].y=3; + side[2][2].x=3,side[2][2].y=2; + side[2][3].x=3,side[2][3].y=3; + side[3][0].x=2,side[3][0].y=4; + side[3][1].x=2,side[3][1].y=5; + side[3][2].x=3,side[3][2].y=4; + side[3][3].x=3,side[3][3].y=5; + side[4][0].x=2,side[4][0].y=6; + side[4][1].x=2,side[4][1].y=7; + side[4][2].x=3,side[4][2].y=6; + side[4][3].x=3,side[4][3].y=7; + side[5][0].x=4,side[5][0].y=2; + side[5][1].x=4,side[5][1].y=3; + side[5][2].x=5,side[5][2].y=2; + side[5][3].x=5,side[5][3].y=3; +} +char get_color(int A,int B,int C) +{ + for(int i=0; i<8; i++) + { + if(rubik[cube[i][0].x][cube[i][0].y]==color[A]&&rubik[cube[i][1].x][cube[i][1].y]==color[B]&&rubik[cube[i][2].x][cube[i][2].y]!=color[C]) + return rubik[cube[i][2].x][cube[i][2].y]; + if(rubik[cube[i][1].x][cube[i][1].y]==color[A]&&rubik[cube[i][0].x][cube[i][0].y]==color[B]&&rubik[cube[i][2].x][cube[i][2].y]!=color[C]) + return rubik[cube[i][2].x][cube[i][2].y]; + if(rubik[cube[i][0].x][cube[i][0].y]==color[A]&&rubik[cube[i][2].x][cube[i][2].y]==color[B]&&rubik[cube[i][1].x][cube[i][1].y]!=color[C]) + return rubik[cube[i][1].x][cube[i][1].y]; + if(rubik[cube[i][2].x][cube[i][2].y]==color[A]&&rubik[cube[i][0].x][cube[i][0].y]==color[B]&&rubik[cube[i][1].x][cube[i][1].y]!=color[C]) + return rubik[cube[i][1].x][cube[i][1].y]; + if(rubik[cube[i][1].x][cube[i][1].y]==color[A]&&rubik[cube[i][2].x][cube[i][2].y]==color[B]&&rubik[cube[i][0].x][cube[i][0].y]!=color[C]) + return rubik[cube[i][0].x][cube[i][0].y]; + if(rubik[cube[i][2].x][cube[i][2].y]==color[A]&&rubik[cube[i][1].x][cube[i][1].y]==color[B]&&rubik[cube[i][0].x][cube[i][0].y]!=color[C]) + return rubik[cube[i][0].x][cube[i][0].y]; + } +} +void turn_x(char maze[10][10]) +{ + char tmp; + tmp=maze[2][4]; + maze[2][4]=maze[2][5]; + maze[2][5]=maze[3][5]; + maze[3][5]=maze[3][4]; + maze[3][4]=tmp; + tmp=maze[1][3]; + maze[1][3]=maze[2][6]; + maze[2][6]=maze[5][3]; + maze[5][3]=maze[3][3]; + maze[3][3]=tmp; + tmp=maze[0][3]; + maze[0][3]=maze[3][6]; + maze[3][6]=maze[4][3]; + maze[4][3]=maze[2][3]; + maze[2][3]=tmp; +} +void turn_y(char maze[10][10]) +{ + char tmp; + tmp=maze[2][0]; + maze[2][0]=maze[2][6]; + maze[2][6]=maze[2][4]; + maze[2][4]=maze[2][2]; + maze[2][2]=tmp; + tmp=maze[2][1]; + maze[2][1]=maze[2][7]; + maze[2][7]=maze[2][5]; + maze[2][5]=maze[2][3]; + maze[2][3]=tmp; + tmp=maze[0][2]; + maze[0][2]=maze[0][3]; + maze[0][3]=maze[1][3]; + maze[1][3]=maze[1][2]; + maze[1][2]=tmp; +} +void turn_z(char maze[10][10]) +{ + char tmp; + tmp=maze[2][1]; + maze[2][1]=maze[1][3]; + maze[1][3]=maze[3][4]; + maze[3][4]=maze[4][2]; + maze[4][2]=tmp; + tmp=maze[3][1]; + maze[3][1]=maze[1][2]; + maze[1][2]=maze[2][4]; + maze[2][4]=maze[4][3]; + maze[4][3]=tmp; + tmp=maze[2][2]; + maze[2][2]=maze[2][3]; + maze[2][3]=maze[3][3]; + maze[3][3]=maze[3][2]; + maze[3][2]=tmp; +} +int get_h(char mid[10][10]) +{ + int i,j,sum = 0; + for(i = 0; i<6; i++) + { + for(j = 0; j<4; j++) + { + if(mid[side[i][j].x][side[i][j].y]!=color[i]) + sum++; + } + } + return (sum+7)/8; +} +int IDA(char mid[10][10],int cnt) +{ + if(cnt+get_h(mid)>step) + return 0; + if(cnt == step) + return 1; + for(int i = 0; i<3; i++) + { + char tem[10][10]; + for(int x = 0; x<6; x++) + for(int y = 0; y<8; y++) + tem[x][y]=mid[x][y]; + if(i == 0) + turn_x(tem); + else if(i == 1) + turn_y(tem); + else + turn_z(tem); + ans[cnt] = i; + if(IDA(tem,cnt+1)) + return 1; + } + return 0; +} +int main() +{ + int i; + init(); + while(~scanf("%s",rubik[0])) + { + for(i = 1; i<6; i++) + scanf("%s",rubik[i]); + if(!strcmp(rubik[0],"........")) + break; + color[1]=rubik[3][0]; + color[5]=rubik[5][2]; + color[4]=rubik[3][7]; + color[0]=get_color(1,4,5); + color[2]=get_color(1,5,4); + color[3]=get_color(4,5,1); + step = 0; + while(1) + { + if(IDA(rubik,0)) break; + step++; + } + for(i = 0; i +#include +#include +struct dic +{ + struct dic *child[26]; +}; +struct dic *root; +int max; +int ans; +void insert(char *source) +{ + struct dic *now,*newnode; + int i,j; + int len; + len=strlen(source); + max=max>len?max:len; + now=root; + for(i=0;ichild[source[i]-'a']!=NULL) now=now->child[source[i]-'a']; + else + { + newnode=(struct dic*)malloc(sizeof(struct dic)); + for(j=0;j<26;j++) newnode->child[j]=NULL; + now->child[source[i]-'a']=newnode; + now=newnode; + } + } +} +void count(struct dic *now) +{ + int j; + for(j=0;j<26;j++) + { + if(now->child[j]==NULL) continue; + else + { + ans++; + count(now->child[j]); + } + } +} +int main() +{ + int n; + int i,j; + char str[55]; + while(scanf("%d",&n)!=-1) + { + root=(struct dic *)malloc(sizeof(struct dic)); + for(j=0;j<26;j++) root->child[j]=0; + max=0; + for(i=0;i +#include +int set[10000005]; +int count; +#define mod 1000000007 +int find(int x) +{ + int r=x; + while(r!=set[r]) + r=set[r]; + int i=x; + while(i!=r) + { + int j=set[i]; + set[i]=r; + i=j; + } + return r; +} +void merge(int x,int y) +{ + int fx=find(x); + int fy=find(y); + if(fx!=fy) + { + set[fx]=fy; + count++; + } +} +long long exp(int n){ + long long sum=1, tmp=26; + while(n){ + if(n&1){ + sum = sum*tmp; + sum %= mod; + } + tmp = (tmp*tmp)%mod; + n>>=1; + } + return sum; +} +int main() +{ + int n,m,l,r; + while(scanf("%d%d",&n,&m)!=EOF) + { + count=0; + for(int i=0;i<=n;i++) + set[i]=i; + for(int i=1;i<=m;i++) + { + scanf("%d%d",&l,&r); + merge(l-1,r); + } + printf("%lld\n",exp(n-count)%mod); + } + return 0; +} diff --git a/HDOJ/3462_autoAC.cpp b/HDOJ/3462_autoAC.cpp new file mode 100644 index 0000000..4975db5 --- /dev/null +++ b/HDOJ/3462_autoAC.cpp @@ -0,0 +1,138 @@ +#include +#include +#include +#include +using namespace std; +#define inf 1000000000 +struct edge +{ + int to,cost,next; + int T, mod; +}e[32000]; +struct node +{ + int x,y,z; + node(int _x=0, int _y=0, int _z=0):x(_x),y(_y),z(_z){} + bool operator<(const node& a)const + { + return y>a.y; + } +}; +priority_queue que; +bool visit[4000]; +int dis[4000][2]; +int pre[4000]; +int next[8000]; +int n,m,num; +int a[40][40]; +void addedge(int from, int to, int cost, int T, int mod) +{ + e[num].to=to;e[num].cost=cost; + e[num].T=T;e[num].mod=mod; + e[num].next=pre[from]; + pre[from]=num; + num++; +} +void make_map() +{ + num=1; + memset(pre, 0, sizeof(pre)); + for (int i=0; i +#include +#include +#include +using namespace std; +#define inf 1000000000 +struct edge +{ + int to,cost,next; + int T, mod; +}e[32000]; +struct node +{ + int x,y,z; + node(int _x=0, int _y=0, int _z=0):x(_x),y(_y),z(_z){} + bool operator<(const node& a)const + { + return y>a.y; + } +}; +priority_queue que; +bool visit[4000]; +int dis[4000][2]; +int pre[4000]; +int next[8000]; +int n,m,num; +int a[40][40]; +void addedge(int from, int to, int cost, int T, int mod) +{ + e[num].to=to;e[num].cost=cost; + e[num].T=T;e[num].mod=mod; + e[num].next=pre[from]; + pre[from]=num; + num++; +} +void make_map() +{ + num=1; + memset(pre, 0, sizeof(pre)); + for (int i=0; i +#include +#include +using namespace std; +const int mod=100007; +int dp[30]; +int succ[mod],cycle; +void get_T(int m) +{ + int cnt=1; + memset(succ,-1,sizeof(succ)); + succ[0]=0; + int now=0; + while(1) + { + now=(now*10+2)%m; + if (succ[now]!=-1) + { + cycle=cnt-succ[now]; + break; + } + succ[now]=cnt++; + } +} +int cal(int x,int m) +{ + if (x==1) return 1; + get_T(m); + int tmp=cal(x-1,cycle); + int now=0; + while(tmp--) + { + now=now*10+2; + if (now>=m) + { + int t=(now-mod)/m; + now=now-t*m; + } + } + return now; +} +int main() +{ + for (int i=1;i<10;i++) + { + dp[i]=(9*cal(i,mod)+1)%mod; + } + int n; + while(scanf("%d",&n)!=EOF) + { + int ans; + if (n<=9) + ans=n==1?1:dp[n-1]; + else + if (n%2==1) + ans=dp[8]; + else ans=dp[7]; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/3465_autoAC.cpp b/HDOJ/3465_autoAC.cpp new file mode 100644 index 0000000..6f86b68 --- /dev/null +++ b/HDOJ/3465_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +#define lowbit(x) (x&(-x)) +const int maxn=5e4+10; +struct node{ + double a,b; + int num; +}e[maxn]; +double l,r; +int c[maxn]; +int cmp1(node x,node y) +{ + if(x.a==y.a)return x.by.a; + return x.b>y.b; +} +void add(int x,int val) +{ + while(x0) + { + s+=c[x]; + x-=lowbit(x); + } + return s; +} +int main() +{ + int n; + while(scanf("%d",&n)!=EOF) + { + int t,tt,i,j,ans=0; + double x1,y1,x2,y2,k,b; + t=tt=0; + scanf("%lf%lf",&l,&r); + for(i=0;il)tt++; + continue; + } + k=(y2-y1)/(x2-x1); + b=y1-k*x1; + e[t].a=l*k+b; + e[t++].b=r*k+b; + } + sort(e,e+t,cmp1); + for(i=0;i +#include +#include +#include +#include +#include +#include +#define LL long long +using namespace std; +typedef struct +{ + int p,q,v; +}item; +const int N = 510; +const int M = 5010; +int n,m; +item t[N]; +int dp[M]; +void zero_dp(int i) +{ + for(int j = m; j >= t[i].p && j >= t[i].q; j--) + dp[j] = max(dp[j], dp[j-t[i].p]+t[i].v); +} +int cmp(const void *a, const void *b) +{ + item *aa = (item *)a, *bb = (item *)b; + return (aa->q-aa->p) - (bb->q-bb->p); +} +int main() +{ + int i,j,k; + while(~scanf("%d%d", &n, &m)) + { + for(i = 0; i < n; i++) + { + scanf("%d%d%d", &t[i].p, &t[i].q, &t[i].v); + if(t[i].q > m) i--,n--; + } + qsort(t, n, sizeof(t[0]), cmp); + memset(dp, 0, sizeof(dp)); + for(i = 0; i < n; i++) + zero_dp(i); + printf("%d\n", dp[m]); + } + return 0; +} diff --git a/HDOJ/3467_autoAC.cpp b/HDOJ/3467_autoAC.cpp new file mode 100644 index 0000000..0cf01c3 --- /dev/null +++ b/HDOJ/3467_autoAC.cpp @@ -0,0 +1,218 @@ +#include +#include +#include +#include +const int maxn = 10; +const double eps = 1e-8; +const double PI = acos(-1.0); +int dcmp(double x) +{ return (x > eps) - (x < -eps); } +struct Point +{ + double x, y; + Point(double x=0, double y=0):x(x), y(y) {} + void read() { scanf("%lf%lf", &x, &y); } +}; +typedef Point Vector; +Point operator + (const Vector& a, const Vector& b) +{ return Point(a.x+b.x, a.y+b.y); } +Point operator - (const Vector& a, const Vector& b) +{ return Point(a.x-b.x, a.y-b.y); } +Vector operator * (const Vector& a, double p) +{ return Point(a.x*p, a.y*p); } +Vector operator / (const Vector& a, double p) +{ return Point(a.x/p, a.y/p); } +bool operator == (const Point& a, const Point& b) +{ return dcmp(a.x-b.x) == 0 && dcmp(a.y-b.y) == 0; } +double Dot(const Vector& a, const Vector& b) +{ return a.x*b.x + a.y*b.y; } +double Cross(const Vector& a, const Vector& b) +{ return a.x*b.y - a.y*b.x; } +double Length(const Vector& a) +{ return sqrt(Dot(a, a)); } +Vector unit(const Vector& a) +{ return a / Length(a); } +Vector Normal(const Vector& a) +{ + double l = Length(a); + return Vector(-a.y/l, a.x/l); +} +double Angle(const Vector& a) +{ return atan2(a.y, a.x); } +Point Rotate(const Point& p, double angle, const Point& o = Point(0, 0)) +{ + Vector t = p - o; + t = Vector(t.x*cos(angle)-t.y*sin(angle), t.x*sin(angle)+t.y*cos(angle)); + return t + o; +} +struct Region +{ + double st, ed; + Region(double s=0, double e=0):st(s), ed(e) {} +}; +struct Circle +{ + Point c; + double r; + Circle() {} + Circle(Point c, double r):c(c), r(r) {} + void read() { c.read(); scanf("%lf", &r); } + double area() const { return PI * r * r; } + bool contain(const Circle& rhs) const + { return dcmp(Length(c-rhs.c) + rhs.r - r) <= 0; } + bool contain(const Point& p) const + { return dcmp(Length(c-p) - r) <= 0; } + bool intersect(const Circle& rhs) const + { return dcmp(Length(c-rhs.c) - r - rhs.r) < 0; } + bool tangency(const Circle& rhs) const + { return dcmp(Length(c-rhs.c) - r - rhs.r) == 0; } + Point get_point(double ang) const + { return Point(c.x + r * cos(ang), c.y + r * sin(ang)); } +}; +void IntersectionPoint(const Circle& c1, const Circle& c2, Point& p1, Point& p2) +{ + double d = Length(c1.c - c2.c); + double l = (c1.r*c1.r + d*d - c2.r*c2.r) / (2 * d); + double h = sqrt(c1.r*c1.r - l*l); + Point mid = c1.c + unit(c2.c-c1.c) * l; + Vector t = Normal(c2.c - c1.c) * h; + p1 = mid + t; + p2 = mid - t; +} +double IntersectionArea(const Circle& c1, const Circle& c2) +{ + double area = 0.0; + const Circle& M = c1.r > c2.r ? c1 : c2; + const Circle& N = c1.r > c2.r ? c2 : c1; + double d = Length(c1.c-c2.c); + if(d < M.r + N.r && d > M.r - N.r) + { + double Alpha = 2.0 * acos((M.r*M.r + d*d - N.r*N.r) / (2 * M.r * d)); + double Beta = 2.0 * acos((N.r*N.r + d*d - M.r*M.r) / (2 * N.r * d)); + area = ( M.r*M.r*(Alpha - sin(Alpha)) + N.r*N.r*(Beta - sin(Beta)) ) / 2.0; + } + else if(d <= M.r - N.r) area = N.area(); + return area; +} +struct Region_vector +{ + int n; + Region v[5]; + void clear() { n = 0; } + void add(const Region& r) { v[n++] = r; } +} *last, *cur; +Circle cir[maxn]; +bool del[maxn]; +double r; +int n = 5; +bool IsOnlyOnePoint() +{ + bool flag = false; + Point t; + for(int i = 0; i < n; ++i) + { + for(int j = i + 1; j < n; ++j) + { + if(cir[i].tangency(cir[j])) + { + t = (cir[i].c + cir[j].c) / 2; + flag = true; + break; + } + } + } + if(!flag) return false; + for(int i = 0; i < n; ++i) + if(!cir[i].contain(t)) return false; + printf("Only the point (%.2f, %.2f) is for victory.\n", t.x, t.y); + return true; +} +bool solve() +{ + if(IsOnlyOnePoint()) return true; + memset(del, false, sizeof(del)); + for(int i = 0; i < n; ++i) + for(int j = 0; j < n; ++j) + { + if(del[j] || i == j) continue; + if(cir[i].contain(cir[j])) + { + del[i] = true; + break; + } + } + double ans = 0.0; + for(int i = 0; i < n; ++i) + { + if(del[i]) continue; + last->clear(); + Point p1, p2; + for(int j = 0; j < n; ++j) + { + if(del[j] || i == j) continue; + if(!cir[i].intersect(cir[j])) return false; + cur->clear(); + IntersectionPoint(cir[i], cir[j], p1, p2); + double rs = Angle(p2 - cir[i].c); + double rt = Angle(p1 - cir[i].c); + if(dcmp(rs) < 0) rs += 2 * PI; + if(dcmp(rt) < 0) rt += 2 * PI; + if(last->n == 0) + { + if(dcmp(rt - rs) < 0) + { + cur->add(Region(rs, 2*PI)); + cur->add(Region(0, rt)); + } + else cur->add(Region(rs, rt)); + } + else + { + for(int k = 0; k < last->n; ++k) + { + if(dcmp(rt - rs) < 0) + { + if(dcmp(last->v[k].st-rt) >= 0 && dcmp(last->v[k].ed-rs) <= 0) continue; + if(dcmp(last->v[k].st-rt) < 0) cur->add(Region(last->v[k].st, std::min(last->v[k].ed, rt))); + if(dcmp(last->v[k].ed-rs) > 0) cur->add(Region(std::max(last->v[k].st, rs), last->v[k].ed)); + } + else + { + if(dcmp(rt-last->v[k].st <= 0 || dcmp(rs-last->v[k].ed) >= 0)) continue; + cur->add(Region(std::max(rs, last->v[k].st), std::min(rt, last->v[k].ed))); + } + } + } + std::swap(cur, last); + if(last->n == 0) break; + } + for(int j = 0; j < last->n; ++j) + { + p1 = cir[i].get_point(last->v[j].st); + p2 = cir[i].get_point(last->v[j].ed); + ans += Cross(p1, p2) / 2; + double ang = last->v[j].ed - last->v[j].st; + ans += cir[i].r * cir[i].r * (ang - sin(ang)) / 2; + } + } + if(dcmp(ans) == 0) return false; + printf("The total possible area is %.2f.\n", ans); + return true; +} +int main(void) +{ + last = new Region_vector; + cur = new Region_vector; + while(scanf("%lf", &r) == 1) + { + Point t; + for(int i = 0; i < n; ++i) + { + t.read(); + cir[i] = Circle(t, r); + } + if(!solve()) + puts("Poor iSea, maybe 2012 is coming!"); + } + return 0; +} diff --git a/HDOJ/3468_autoAC.cpp b/HDOJ/3468_autoAC.cpp new file mode 100644 index 0000000..c4fc975 --- /dev/null +++ b/HDOJ/3468_autoAC.cpp @@ -0,0 +1,197 @@ +#include +#include +#include +#include +#include +#define MAXN 105*105*2 +#define MAXM 105*105*100 +#define inf 0x3f3f3f3f +using namespace std; +struct node +{ + int u,v,f; +}; +node e[MAXM]; +int first[MAXN],ne[MAXM]; +int gap[MAXN],d[MAXN],curedge[MAXN],pre[MAXN]; +int cc, n,m; +inline void add_edge(int u,int v,int f) +{ + e[cc].u=u; + e[cc].v=v; + e[cc].f=f; + ne[cc]=first[u]; + first[u]=cc; + cc++; + e[cc].u=v; + e[cc].v=u; + e[cc].f=0; + ne[cc]=first[v]; + first[v]=cc; + cc++; +} +int ISAP(int s,int t,int n) +{ + int cur_flow,flow_ans=0,u,tmp,neck,i,v; + memset(d,0,sizeof(d)); + memset(gap,0,sizeof(gap)); + memset(pre,-1,sizeof(pre)); + for(i=0;i<=n;i++) + curedge[i]=first[i]; + gap[0]=n+1; + u=s; + while(d[s]<=n) + { + if(u==t) + { + cur_flow=inf; + for(i=s;i!=t;i=e[curedge[i]].v) + { + if(cur_flow>e[curedge[i]].f) + { + neck=i; + cur_flow=e[curedge[i]].f; + } + } + for(i=s;i!=t;i=e[curedge[i]].v) + { + tmp=curedge[i]; + e[tmp].f-=cur_flow; + e[tmp^1].f+=cur_flow; + } + flow_ans+=cur_flow; + u=neck; + } + for(i=curedge[u];i!=-1;i=ne[i]) + { + v=e[i].v; + if(e[i].f&&d[u]==d[v]+1) + break; + } + if(i!=-1) + { + curedge[u]=i; + pre[v]=u; + u=v; + } + else + { + if(0==--gap[d[u]]) + break; + curedge[u]=first[u]; + for(tmp=n+5,i=first[u];i!=-1;i=ne[i]) + if(e[i].f) + tmp=min(tmp,d[e[i].v]); + d[u]=tmp+1; + ++gap[d[u]]; + if(u!=s) + u=pre[u]; + } + } + return flow_ans; +} +char map[105][105]; +int rally[105*105]; +int gold[105*105]; +int pos[105*105]; +int dist[55][105*105]; +int vis[105][105]; +int xx[4]={0,1,0,-1}; +int yy[4]={1,0,-1,0}; +int trans(char word) +{ + if(word>='A'&&word<='Z') + return word-'A'; + else + return word-'a'+26; +} +void bfs(int s) +{ + queue q; + memset(vis,0,sizeof(vis)); + memset(dist[s],inf,sizeof(dist[s])); + int t=pos[s]; + vis[t/m][t%m]=1; + q.push(t); + dist[s][t]=0; + while(!q.empty()) + { + int u=q.front(); + q.pop(); + int x=u/m; + int y=u%m; + int i; + for(i=0;i<4;i++) + { + int nx=x+xx[i]; + int ny=y+yy[i]; + if(nx<0||nx>=n||ny<0||ny>=m) + continue; + if(vis[nx][ny]||map[nx][ny]=='#') + continue; + vis[nx][ny]=1; + dist[s][nx*m+ny]=dist[s][x*m+y]+1; + q.push(nx*m+ny); + } + } +} +int main() +{ + while(scanf("%d%d",&n,&m)!=EOF) + { + memset(first,-1,sizeof(first)); + memset(ne,-1,sizeof(ne)); + cc=0; + memset(pos,0,sizeof(pos)); + int i,j; + int cnt1=0; + int cnt2=0; + for(i=0;i +#include +int main() +{ + int t, n, re, i; + scanf("%d", &t); + for(i=1; i<=t; i++) + { + scanf("%d", &n); + if(n==1) + re=1; + else if(n==2) + re=2; + else + re=2*n-4; + printf("Case %d: %d\n", i, re); + } + return 0; +} diff --git a/HDOJ/3470_autoAC.cpp b/HDOJ/3470_autoAC.cpp new file mode 100644 index 0000000..f20ba42 --- /dev/null +++ b/HDOJ/3470_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#define maxn 1000010 +using namespace std; +typedef long long LL; +int width,height,n; +int L,R,U,D,v; +bool diffx,diffy; +int idx[maxn],idy[maxn]; +char ch[10]; +void init(int id[],int n) +{ + id[0]=id[n]=0; + for (int i=1;iabs(R-v)) diff=!diff,dir=true; + for (int x=v,y=v;x!=L&&y!=R;x--,y++) + { + if (!dir) + { + id[y]+=id[x]; + id[x]=0; + } + else + { + id[x]+=id[y]; + id[y]=0; + } + } + if (!dir) L=v; + else R=v; + return ret; +} +int main() +{ + int test; + scanf("%d",&test); + for (int ii=1;ii<=test;ii++) + { + scanf("%d%d",&width,&height); + scanf("%d",&n); + diffx=diffy=0; + L=D=0;U=height;R=width; + init(idx,width); + init(idy,height); + LL ans=0; + for (int i=1;i<=n;i++) + { + scanf("%s%d",ch,&v); + if (ch[0]=='L'||ch[0]=='R') + { + if (diffx) v=R-L-v; + if (!diffx && ch[0]=='R') diffx=!diffx; + if (diffx && ch[0]=='L') diffx=!diffx; + ans+=(LL)height*fold(idx, L, R, v, diffx); + } + else + { + if (diffy) v=U-D-v; + if (!diffy && ch[0]=='U') diffy=!diffy; + if (diffy && ch[0]=='D') diffy=!diffy; + ans+=(LL)width*fold(idy, D, U, v, diffy); + } + } + printf("Case %d: %I64d\n",ii,ans); + } + return 0; +} diff --git a/HDOJ/3471_autoAC.cpp b/HDOJ/3471_autoAC.cpp new file mode 100644 index 0000000..c290137 --- /dev/null +++ b/HDOJ/3471_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define MAX 1<<30 +using namespace std; +const double eps=1e-8; +typedef long long ll; +int main() +{ + typedef struct + { + double x; + double y; + double z; + } plus; + plus r[100],xa[100],p[100]; + int t,i,j,k,ca=0; + double temp[6],pp[100]; + plus o,v,m,f; + scanf("%d",&t); + while(t--) + { + scanf("%lf%lf%lf",&o.x,&o.y,&o.z); + scanf("%lf%lf%lf",&v.x,&v.y,&v.z); + printf("Case %d: ",++ca); + for(i=0;i<8;i++) + scanf("%lf%lf%lf",&p[i].x,&p[i].y,&p[i].z); + m.x=p[4].x-p[0].x; + m.y=p[4].y-p[0].y; + m.z=p[4].z-p[0].z; + if(m.x*v.x+m.y*v.y+m.z*v.z<=eps) + { + printf("Intelligent Larrionda!!!\n"); + continue; + } + temp[0] =( (p[0].x-o.x)*m.x+(p[0].y-o.y)*m.y+(p[0].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z); + temp[1] =( (p[4].x-o.x)*m.x+(p[4].y-o.y)*m.y+(p[4].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z); + if(temp[0]<=eps&&temp[1]<=eps) + { + printf("Intelligent Larrionda!!!\n"); + continue; + } + f.x = o.x + temp[0]*v.x; + f.y = o.y + temp[0]*v.y; + f.z = o.z + temp[0]*v.z; + for(i=0;i<4;i++) + { + r[i].x = p[i].x - f.x; + r[i].y = p[i].y - f.y; + r[i].z = p[i].z - f.z; + } + for(i=0;i<3;i++) + { + xa[i].x= r[i+1].z*r[i].y-r[i+1].y*r[i].z; + xa[i].y= r[i+1].x*r[i].z-r[i+1].z*r[i].x; + xa[i].z= r[i+1].y*r[i].x-r[i+1].x*r[i].y; + } + xa[3].x=-( r[3].z*r[0].y-r[3].y*r[0].z); + xa[3].y=-( r[3].x*r[0].z-r[3].z*r[0].x); + xa[3].z=-( r[3].y*r[0].x-r[3].x*r[0].y); + for(i=0;i<3;i++) + { + if(xa[i].x*xa[i+1].x+xa[i].y*xa[i+1].y+xa[i].z*xa[i+1].z>0); + else + {printf("Intelligent Larrionda!!!\n");break;} + } + if(i==3) + printf("Stupid Larrionda!!!\n"); + } + return 0; +} diff --git a/HDOJ/3472_autoAC.cpp b/HDOJ/3472_autoAC.cpp new file mode 100644 index 0000000..d2b1ef2 --- /dev/null +++ b/HDOJ/3472_autoAC.cpp @@ -0,0 +1,189 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 30; +const int MAXM = 10000; +const int INF = 0x3f3f3f3f; +struct Edge +{ + int to,next,cap,flow; +}edge[MAXM]; +int tol; +int head[MAXN]; +int gap[MAXN], dep[MAXN], pre[MAXN], cur[MAXN]; +void init() +{ + tol = 0; + memset(head,-1,sizeof(head)); +} +void addedge(int u,int v,int w,int rw = 0) +{ + edge[tol].to = v; + edge[tol].cap = w; + edge[tol].next = head[u]; + edge[tol].flow = 0; + head[u] = tol++; + edge[tol].to = u; + edge[tol].cap = rw; + edge[tol].next = head[v]; + edge[tol].flow = 0; + head[v] = tol++; +} +int sap(int start,int end,int N) +{ + memset(gap,0,sizeof(gap)); + memset(dep,0,sizeof(dep)); + memcpy(cur,head,sizeof(head)); + int u = start; + pre[u] = -1; + gap[0] = N; + int ans = 0; + while(dep[start] < N) + { + if(u == end) + { + int Min = INF; + for(int i = pre[u];i != -1;i = pre[edge[i^1].to]) + if(Min > edge[i].cap - edge[i].flow) + Min = edge[i].cap - edge[i].flow; + for(int i = pre[u]; i != -1;i = pre[edge[i^1].to]) + { + edge[i].flow += Min; + edge[i^1].flow -= Min; + } + u = start; + ans += Min; + continue; + } + bool flag = false; + int v; + for(int i = cur[u]; i != -1;i = edge[i].next) + { + v = edge[i].to; + if(edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]) + { + flag = true; + cur[u] = pre[v] = i; + break; + } + } + if(flag) + { + u = v; + continue; + } + int Min = N; + for(int i = head[u]; i != -1;i = edge[i].next) + if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) + { + Min = dep[edge[i].to]; + cur[u] = i; + } + gap[dep[u]] --; + if(!gap[dep[u]])return ans; + dep[u] = Min+1; + gap[dep[u]]++; + if(u != start) u = edge[pre[u]^1].to; + } + return ans; +} +int in[30],out[30]; +int F[30]; +int find(int x) +{ + if(F[x] == -1)return x; + else return F[x] = find(F[x]); +} +void bing(int u,int v) +{ + int t1 = find(u), t2 = find(v); + if(t1 != t2)F[t1] = t2; +} +char str[100]; +int main() +{ + int T,n; + scanf("%d",&T); + int iCase = 0; + while(T--) + { + iCase++; + scanf("%d",&n); + memset(F,-1,sizeof(F)); + memset(in,0,sizeof(in)); + memset(out,0,sizeof(out)); + init(); + int k; + int s = -1; + while(n--) + { + scanf("%s%d",str,&k); + int len = strlen(str); + int u = str[0] - 'a'; + int v = str[len-1] - 'a'; + out[u]++; + in[v]++; + s = u; + if(k == 1) + addedge(u,v,1); + bing(u,v); + } + bool flag = true; + int cnt = 0; + int s1 = -1, s2 = -1; + for(int i = 0;i < 26;i++) + if(in[i] || out[i]) + { + if(find(i) != find(s)) + { + flag = false; + break; + } + if((in[i] + out[i])&1) + { + cnt++; + if(s1 == -1)s1 = i; + else s2 = i; + } + } + if(cnt != 0 && cnt != 2)flag = false; + if(!flag) + { + printf("Case %d: Poor boy!\n",iCase); + continue; + } + if(cnt == 2) + { + out[s1]++; + in[s2]++; + addedge(s1,s2,1); + } + for(int i = 0;i < 26;i++) + { + if(out[i] - in[i] > 0) + addedge(26,i,(out[i] - in[i])/2); + else if(in[i] - out[i] > 0) + addedge(i,27,(in[i] - out[i])/2); + } + sap(26,27,28); + for(int i = head[26];i != -1;i = edge[i].next) + if(edge[i].cap > 0 && edge[i].cap > edge[i].flow) + { + flag = false; + break; + } + if(flag)printf("Case %d: Well done!\n",iCase); + else printf("Case %d: Poor boy!\n",iCase); + } + return 0; +} diff --git a/HDOJ/3473_autoAC.cpp b/HDOJ/3473_autoAC.cpp new file mode 100644 index 0000000..c240ea2 --- /dev/null +++ b/HDOJ/3473_autoAC.cpp @@ -0,0 +1,97 @@ +#include +#include +#include +#define MAXK 20 +#define MAXD 100010 +int N, M, sa[MAXD], a[MAXD], rank[MAXK][MAXD], h[MAXK][MAXD]; +long long int A[MAXK][MAXD], ans; +int cmp(const void *_p, const void *_q) +{ + int *p = (int *)_p, *q = (int *)_q; + if(a[*p] == a[*q]) + return *p - *q; + return a[*p] - a[*q]; +} +void init() +{ + int i, j, k; + scanf("%d", &N); + for(i = 1; i <= N; i ++) + { + scanf("%d", &a[i]); + sa[i] = i; + } +} +void build(int lx, int rx, int d) +{ + if(lx == rx) + { + A[d][lx] = a[sa[rank[d][lx]]]; + return ; + } + int i, j, k, p = 0, mid = (lx + rx) / 2; + for(i = lx; i <= rx; i ++) + { + if(rank[d][i] <= mid) + rank[d + 1][lx + p ++] = rank[d][i]; + else + rank[d + 1][mid + i - lx + 1 - p] = rank[d][i]; + h[d][i] = p; + A[d][i] = a[sa[rank[d][i]]] + (i == lx ? 0 : A[d][i - 1]); + } + build(lx, mid, d + 1); + build(mid + 1, rx, d + 1); +} +int search(int lx, int rx, int x, int y, int k, int d) +{ + if(lx == rx) + return sa[rank[d][lx]]; + int j, n, m, mid = (lx + rx) / 2, tx, ty; + n = h[d][y], m = x == lx ? 0 : h[d][x - 1]; + if(n - m >= k) + { + j = search(lx, mid, lx + m, lx + n - 1, k, d + 1); + tx = mid + 1 + x - lx - m, ty = mid + 1 + y - lx - n; + if(tx <= ty) + ans += A[d + 1][ty] - (tx == mid + 1 ? 0 : A[d + 1][tx - 1]) - (long long int)(ty - tx + 1) * a[j]; + } + else + { + j = search(mid + 1, rx, mid + 1 + x - lx - m, mid + 1 + y - lx - n, k - n + m, d + 1); + tx = lx + m, ty = lx + n - 1; + if(tx <= ty) + ans += (long long int)(ty - tx + 1) * a[j] - A[d + 1][ty] + (tx == lx ? 0 : A[d + 1][tx - 1]); + } + return j; +} +void solve() +{ + int i, j, k, x, y; + qsort(sa + 1, N, sizeof(sa[0]), cmp); + for(i = 1; i <= N; i ++) + rank[0][sa[i]] = i; + build(1, N, 0); + scanf("%d", &M); + for(i = 0; i < M; i ++) + { + scanf("%d%d", &x, &y); + ++ x, ++ y; + k = (y - x) / 2 + 1; + ans = 0; + search(1, N, x, y, k, 0); + printf("%I64d\n", ans); + } +} +int main() +{ + int t, tt; + scanf("%d", &t); + for(tt = 0; tt < t; tt ++) + { + init(); + printf("Case #%d:\n", tt + 1); + solve(); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/3475_autoAC.cpp b/HDOJ/3475_autoAC.cpp new file mode 100644 index 0000000..c7e31f0 --- /dev/null +++ b/HDOJ/3475_autoAC.cpp @@ -0,0 +1,134 @@ +#include +#include +#include +#define MAXN 110 +#define MAXM 15 +#define MAXD 10010 +#define HASH 10007 +#define ST 1030 +#define INF 0x3f3f3f3f +int N, M, D, d[MAXN][MAXM][8], g[MAXN][MAXM], first[ST], e, next[ST], v[ST]; +char b[MAXN]; +struct HashMap +{ + int head[HASH], size, next[MAXD], st[MAXD], ans[MAXD]; + void init() + { + memset(head, -1, sizeof(head)), size = 0; + } + void push(int _st, int _ans) + { + int i, h = _st % HASH; + for(i = head[h]; i != -1; i = next[i]) + if(st[i] == _st) break; + if(i == -1) + { + if(_st == -1) for(;;); + st[size] = _st, ans[size] = _ans; + next[size] = head[h], head[h] = size ++; + } + else ans[i] = std::min(ans[i], _ans); + } +}hm[2]; +void add(int x, int y) +{ + v[e] = y; + next[e] = first[x], first[x] = e ++; +} +void prepare(int i) +{ + int j, k, st; + memset(first, -1, sizeof(first)), e = 0; + for(j = 0; j <= D; j ++) + { + st = 0; + for(k = 0; k < M; k ++) + if(j & 1 << k) + { + if(d[i][k][5]) st ^= 1 << k - 1; + if(d[i][k][4]) st ^= 1 << k; + if(d[i][k][3]) st ^= 1 << k + 1; + } + add(st, j); + } +} +void init() +{ + int i, j, k; + scanf("%d%d", &N, &M); + memset(d, 0, sizeof(d)); + memset(g, 0, sizeof(g)); + gets(b); + for(i = 0; i < N; i ++) + { + gets(b); + for(j = 0; j < M; j ++) + { + g[i][j] = b[2 * j] == 'o'; + if(j < M - 1 && b[2 * j + 1] == '-') d[i][j][2] = d[i][j + 1][6] = 1; + } + if(i < N - 1) + { + gets(b); + for(j = 0; j < M; j ++) + { + if(b[2 * j] == '|') d[i][j][0] = d[i + 1][j][4] = 1; + if(j < M - 1) + { + if(b[2 * j + 1] == '\\' || b[2 * j + 1] == 'X') d[i][j][1] = d[i + 1][j + 1][5] = 1; + if(b[2 * j + 1] == '/' || b[2 * j + 1] == 'X') d[i][j + 1][7] = d[i + 1][j][3] = 1; + } + } + } + } + D = (1 << M) - 1; +} +void solve() +{ + int i, j, k, t, cur = 0, st, tc, td, nl, ust, cst, cnt, ans = INF; + hm[0].init(); + for(i = st = 0; i < M; i ++) if(g[0][i]) st |= 1 << i; + hm[0].push(st, 0); + for(i = 0; i < N; i ++) + { + hm[cur ^ 1].init(); + prepare(i); + for(j = nl = 0; j < M; j ++) if(g[i + 1][j]) nl |= 1 << j; + for(j = 0; j < hm[cur].size; j ++) + { + ust = hm[cur].st[j] >> M, cst = hm[cur].st[j] & D, td = nl; + for(k = first[ust]; k != -1; k = next[k]) + { + st = v[k], cnt = 0; + tc = cst ^ st, td = nl; + for(t = 0; t < M; t ++) + if(st & 1 << t) + { + ++ cnt; + if(d[i][t][0]) td ^= 1 << t; + if(d[i][t][1]) td ^= 1 << t + 1; + if(d[i][t][2]) tc ^= 1 << t + 1; + if(d[i][t][6]) tc ^= 1 << t - 1; + if(d[i][t][7]) td ^= 1 << t - 1; + } + hm[cur ^ 1].push(tc << M | td, hm[cur].ans[j] + cnt); + } + } + cur ^= 1; + } + for(i = 0; i < hm[cur].size; i ++) + if((hm[cur].st[i] >> M) == 0) ans = std::min(ans, hm[cur].ans[i]); + printf("%d\n", ans == INF ? -1 : ans); +} +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/3476_autoAC.cpp b/HDOJ/3476_autoAC.cpp new file mode 100644 index 0000000..d8344e4 --- /dev/null +++ b/HDOJ/3476_autoAC.cpp @@ -0,0 +1,5 @@ +#include +int main(){ + printf("13579680\n"); + return 0; +} diff --git a/HDOJ/3478_autoAC.cpp b/HDOJ/3478_autoAC.cpp new file mode 100644 index 0000000..1c02ec6 --- /dev/null +++ b/HDOJ/3478_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +using namespace std; +struct Node +{ + int v; + int next; +}Edge[500010*2]; +int pre[100010]; +void add(int u,int v,int index) +{ + Edge[index].v=v; + Edge[index].next=pre[u]; + pre[u]=index; +} +int flag[100010]; +int c[100010]; +int bfs(int v) +{ + queue q; + flag[v]=1; + q.push(v); + while(!q.empty()) + { + int b=q.front(); + q.pop(); + for(int i=pre[b];i!=-1;i=Edge[i].next) + { + int e=Edge[i].v; + if(flag[e]==flag[b]) + return 0; + if(!flag[e]) + { + flag[e]=flag[b]==1?2:1; + q.push(e); + } + } + } + return 1; +} +int main() +{ + int n,m,q,cnt=1; + int t; + scanf("%d",&t); + while(t--) + { + scanf("%d%d%d",&n,&m,&q); + int a,b,index=1; + memset(flag,0,sizeof(flag)); + memset(pre,-1,sizeof(pre)); + memset(c,0,sizeof(c)); + for(int i=0;i +#include +#include +#include +#include +using namespace std; +#define maxn 10005 +int save[maxn],q[maxn],sum[maxn],dp[5005][maxn],ans; +int n,m,h,t; +int M(int k){return k*k;} +void solve() +{ + for(int i=1;i<=n;i++) + { + dp[1][i]=M(save[i]-save[1]); + } + for(int i=2;i<=m;i++) + { + h=t=1; + q[1]=0; + q[++t]=i-1; + for(int j=i;j<=n;j++) + { + while(h +#include +const int MOD = 987654321; +long long dp[110][10]; +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m),n>0) + { + if(m==1){puts("0");continue;} + if(m==2){printf("%d\n",n==1?2:0);continue;} + memset(dp,0,sizeof(dp)); + dp[1][1]=m; + for(int i=1;i<=n;i++) + { + for(int j=1;j1||i==1) + { + for(int k=1;1+k<=m-1;k++) + { + dp[i+k][1]+=dp[i][j]; + } + } + } + } + long long ans=0; + for(int j=1;j +#include +#include +#define maxn 1000009 +#define ll long long +using namespace std; +const ll mod=987654321; +ll f[maxn]; +int main() +{ + ll n,m; + f[1]=1; + for(ll i=2;imod)f[i]%=mod; + } + while(scanf("%lld%lld",&n,&m)&&(n+m)>0) + { + ll ans=1; + if(n0) + { + if(n&1)ans*=m; + if(ans>mod)ans%=mod; + n>>=1; + m*=m; + if(m>mod)m%=mod; + } + } + else + { + ans=f[m]+m; + if(ans>mod)ans%=mod; + } + printf("%lld\n",ans); + } + return 0; +} diff --git a/HDOJ/3483_autoAC.cpp b/HDOJ/3483_autoAC.cpp new file mode 100644 index 0000000..d863833 --- /dev/null +++ b/HDOJ/3483_autoAC.cpp @@ -0,0 +1,57 @@ +#include +#include +using namespace std; +#define M 55 +#define LL long long +#define FF(i, n) for(int i = 0; i < n; i++) +int ans[M], mod, C[M][M]; +int ret[M][M], init[M][M]; +void ini(int n, int x) +{ + memset(init, 0, sizeof(init)); + FF(i, n) FF(j, i+1) + init[i][j] = (LL)x*C[i][j] % mod; + FF(i, n) ans[i] = x; + ans[n] = 0; + init[n][n-1] = init[n][n] = 1; +} +void matmul(int a[][M], int b[][M], int n) +{ + int tp[M][M] = {0}; + FF(i, n) FF(k, n) if(a[i][k]) FF(j, n) if(b[k][j]) + tp[i][j] = (tp[i][j] + (LL)a[i][k]*b[k][j]) % mod; + FF(i, n) FF(j, n) a[i][j] = tp[i][j]; +} +void matmul(int a[], int b[][M], int n) +{ + int tp[M] = {0}; + FF(j, n) if(a[j]) FF(i, n) if(b[i][j]) + tp[i] = (tp[i] + (LL)a[j]*b[i][j]) % mod; + FF(i, n) a[i] = tp[i]; +} +void qmod(int n, int b) +{ + FF(i, n) FF(j, n) ret[i][j] = (i==j); + for( ; b; b >>= 1) + { + if (b & 1) matmul(ret, init, n); + matmul(init, init, n); + } +} +int main() +{ + int i, j, n, x; + while (cin >> n >> x >> mod, n >= 1) + { + for(i = 0; i <= x; i++) + C[i][0] = C[i][i] = 1; + for(i = 2; i <= x; i++) + for(j = 1; j < i; j++) + C[i][j] = ((LL)C[i-1][j-1]+C[i-1][j]) % mod; + ini(x+1, x); + qmod(x+2, n); + matmul(ans, ret, x+2); + cout << ans[x+1] << endl; + } + return 0; +} diff --git a/HDOJ/3484_autoAC.cpp b/HDOJ/3484_autoAC.cpp new file mode 100644 index 0000000..b4cee24 --- /dev/null +++ b/HDOJ/3484_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +using namespace std; +int ma[105][105],tar[105][105],tmp[105][105]; +int n,m; +void init() +{ + for (int i=1;i<=n;i++) + { + for (int j=1;j<=m;j++) + scanf("%d",&ma[i][j]); + } + for (int i=1;i<=n;i++) + { + for (int j=1;j<=m;j++) + scanf("%d",&tar[i][j]); + } +} +void cpy(int c) +{ + for (int i=1;i<=m;i++) + { + for (int j=1;j<=n;j++) + { + tmp[j][i]=ma[j][i]; + } + } +} +void change_col(int a,int b) +{ + for (int i=1;i<=n;i++) + { + int temp=tmp[i][a]; + tmp[i][a]=tmp[i][b]; + tmp[i][b]=temp; + } +} +void change_row(int c) +{ + for (int i=1;i<=m;i++) + tmp[c][i]^=1; +} +bool ok(int a,int b) +{ + for (int i=1;i<=n;i++) + { + if (tar[i][a]!=tmp[i][b]) + return false; + } + return true; +} +int main() +{ + while (scanf("%d%d",&n,&m)) + { + if (n==-1) break; + init(); + bool ans=0; + for (int i=1;i<=m;i++) + { + cpy(i); + change_col(1,i); + for (int j=1;j<=n;j++) + { + if (tmp[j][1]!=tar[j][1]) + change_row(j); + } + for (int j=2;j<=m;j++) + { + for (int k=j;k<=m;k++) + { + ans=ok(j,k); + if (ans) + { + change_col(j,k); + break; + } + } + } + if (ans) break; + } + if (ans) puts("Yes"); + else + puts("No"); + } + return 0; +} diff --git a/HDOJ/3485_autoAC.cpp b/HDOJ/3485_autoAC.cpp new file mode 100644 index 0000000..d743f76 --- /dev/null +++ b/HDOJ/3485_autoAC.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; +int f[10005]; +int n; +int deal(int n) +{ + if(f[n]!=0) + return f[n]; + f[n-1]=deal(n-1)%9997; + f[n-2]=deal(n-2)%9997; + f[n-4]=deal(n-4)%9997; + return ((f[n-1]+f[n-2]+f[n-4])%9997); +} +int main() +{ + while(scanf("%d",&n)!=EOF&&n!=-1) + { + f[0]=1; + f[1]=2; + f[2]=4; + f[3]=7; + printf("%d\n",deal(n)); + } +} diff --git a/HDOJ/3486_autoAC.cpp b/HDOJ/3486_autoAC.cpp new file mode 100644 index 0000000..c93fc24 --- /dev/null +++ b/HDOJ/3486_autoAC.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +using namespace std; +int n,k,l,r,m,tn,temp,t,M,ss; +int f[200001][18]; +int lg[200001]; +void pre_rmq() +{ + for(int j=1;(1<=M+1) return 1; + return 0; +} +int main() +{ + for(int i=2;i<=200000;i++) + lg[i]=lg[i>>1]+1; + while(scanf("%d%d",&n,&M)!=EOF) + { + ss=0; + if(n==-1&&M==-1) break; + for(int i=1;i<=n;i++) + { + scanf("%d",&f[i][0]); + ss+=f[i][0]; + } + if(ss<=M) + { + printf("-1\n"); + continue; + } + pre_rmq(); + l=1;r=n; + while(l<=r) + { + m=(l+r)>>1; + if(check(m)) r=m-1; + else l=m+1; + } + printf("%d\n",l); + } +} diff --git a/HDOJ/3487_autoAC.cpp b/HDOJ/3487_autoAC.cpp new file mode 100644 index 0000000..5cabd36 --- /dev/null +++ b/HDOJ/3487_autoAC.cpp @@ -0,0 +1,174 @@ +#include +#include +#include +#include +#include +#define N 300015 +#define inf 1<<29 +#define MOD 100000007 +#define LL long long +#define Key_value ch[ch[root][1]][0] +#define _match(a,b) ((a)==(b)) +using namespace std; +int n,q; +int size[N],pre[N],key[N],num[N],rev[N]; +int ch[N][2],tot,root,node[N]; +void NewNode(int &r,int k,int father){ + r=++tot; + ch[r][0]=ch[r][1]=0; + pre[r]=father; + rev[r]=0; + key[r]=k; +} +void Push_Up(int r){ + size[r]=size[ch[r][0]]+size[ch[r][1]]+1; +} +void Push_Down(int r){ + if(rev[r]){ + swap(ch[r][0],ch[r][1]); + rev[ch[r][0]]^=1; + rev[ch[r][1]]^=1; + rev[r]=0; + } +} +void Bulid(int &r,int L,int R,int father){ + if(L>R) + return ; + int mid=(L+R)/2; + NewNode(r,mid,father); + Bulid(ch[r][0],L,mid-1,r); + Bulid(ch[r][1],mid+1,R,r); + Push_Up(r); +} +void Init(){ + tot=root=0; + ch[root][0]=ch[root][1]=pre[root]=rev[root]=size[root]=0; + NewNode(root,-1,0); + NewNode(ch[root][1],-1,root); + size[root]=2; + Bulid(Key_value,1,n,ch[root][1]); + Push_Up(ch[root][1]); + Push_Up(root); +} +void Rotate(int x,int kind){ + int y=pre[x]; + Push_Down(y); + Push_Down(x); + ch[y][!kind]=ch[x][kind]; + pre[ch[x][kind]]=y; + if(pre[y]) + ch[pre[y]][ch[pre[y]][1]==y]=x; + pre[x]=pre[y]; + ch[x][kind]=y; + pre[y]=x; + Push_Up(y); +} +void Splay(int r,int goal){ + Push_Down(r); + while(pre[r]!=goal){ + if(pre[pre[r]]==goal) + Rotate(r,ch[pre[r]][0]==r); + else{ + int y=pre[r]; + int kind=(ch[pre[y]][0]==y); + if(ch[y][kind]==r){ + Rotate(r,!kind); + Rotate(r,kind); + } + else{ + Rotate(y,kind); + Rotate(r,kind); + } + } + } + Push_Up(r); + if(goal==0) root=r; +} +int Get_Kth(int r,int k){ + Push_Down(r); + int t=size[ch[r][0]]; + if(t==k-1) + return r; + if(t>=k) + return Get_Kth(ch[r][0],k); + else + return Get_Kth(ch[r][1],k-t-1); +} +int Get_Min(int r){ + Push_Down(r); + while(ch[r][0]){ + r=ch[r][0]; + Push_Down(r); + } + return r; +} +int Get_Max(int r){ + Push_Down(r); + while(ch[r][1]){ + r=ch[r][1]; + Push_Down(r); + } + return r; +} +void Reversal(int a,int b){ + int x=Get_Kth(root,a); + int y=Get_Kth(root,b+2); + Splay(x,0); + Splay(y,root); + rev[Key_value]^=1; +} +void Cut(int a,int b,int c){ + int x=Get_Kth(root,a); + int y=Get_Kth(root,b+2); + Splay(x,0); + Splay(y,root); + int tmp=Key_value; + Key_value=0; + Push_Up(ch[root][1]); + Push_Up(root); + int z=Get_Kth(root,c+1); + Splay(z,0); + int m=Get_Min(ch[root][1]); + Splay(m,root); + Key_value=tmp; + pre[Key_value]=ch[root][1]; + Push_Up(ch[root][1]); + Push_Up(root); +} +int cnt; +void InOrder(int r){ + if(r==0) + return; + Push_Down(r); + InOrder(ch[r][0]); + if(cnt>=1&&cnt<=n){ + if(cnt>1) printf(" "); + printf("%d",key[r]); + } + cnt++; + InOrder(ch[r][1]); +} +int main(){ + while(scanf("%d%d",&n,&q)!=EOF){ + if(n==-1&&q==-1) + break; + Init(); + while(q--){ + char str[10]; + int a,b,c; + scanf("%s",str); + if(str[0]=='C'){ + scanf("%d%d%d",&a,&b,&c); + Cut(a,b,c); + } + else{ + scanf("%d%d",&a,&b); + Reversal(a,b); + } + } + cnt=0; + InOrder(root); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/3488_autoAC.cpp b/HDOJ/3488_autoAC.cpp new file mode 100644 index 0000000..bd63385 --- /dev/null +++ b/HDOJ/3488_autoAC.cpp @@ -0,0 +1,75 @@ +#include +#include +#define inf 1000000 +#define N 205 +int n,y[N],g[N][N],lx[N],ly[N],slack[N]; +char vx[N],vy[N]; +int search(int u) +{ + vx[u]=1; + for(int v=1;v<=n;v++) + if(lx[u]+ly[v]==g[u][v]) + { + if(vy[v]==1) continue; + vy[v]=1; + if(y[v]==-1||search(y[v])) + { + y[v]=u; + return 1; + } + } + else if(lx[u]+ly[v]-g[u][v] +# include +# include +using namespace std; +int p[1002][26],pre[1002],n,m; +char a[10002],b[1002]; +int f[10002][1002]; +void relax(int &i,const int&j){if(i>j) i=j;} +int main() +{ + int Case; scanf("%d",&Case); + while(Case--){ + scanf("%s",a+1); scanf("%s",b+1); + n = strlen(a+1); m = strlen(b+1); + for(int i=1; i<=n; i++)a[i]-='a',b[i]-='a'; + int k = 0; pre[1] = 0; + for(int i=2; i<=m; i++) { + while(k && b[k+1]!=b[i]) k = pre[k]; + if(b[k+1] == b[i]) k++; pre[i]=k; + } + memset(p,0,sizeof(p)); + for(int i=1; i<=m; i++) p[i-1][b[i]]=i; + for(int i=1; i<=m; i++) + for(int j=0; j<26; j++) + if(!p[i][j]) p[i][j] = p[pre[i]][j]; + for(int j=0; j<26; j++) p[m][j] = m; + memset(f,0x7f,sizeof(f)); f[0][0]=0; + for(int i=0; i +#include +#include +#include +#include +using namespace std; + map > ms; + map s1, s2; + int n; + inline int calc(map& s) { + map::iterator ib = s.begin(), ie = s.end(); + return (--ie)->first - ib->first; + } + inline void erase(map &s, int x) { + if (--s[x] == 0) + s.erase(x); + } + int main() { + int test; + scanf("%d", &test); + for (int cas = 1; cas <= test; ++cas) { + ms.clear(); s1.clear(); s2.clear(); + scanf("%d", &n); + for (int i = 0; i < n; ++i) { + int opt; char buf[100]; + scanf("%d%s", &opt, buf); + if (opt == 1) { + int x, y; + scanf("%d%d", &x, &y); + ms[buf] = pair(x, y); + s1[x - y]++; s2[x + y]++; + } else { + map >::iterator it = ms.find(buf); + erase(s1, it->second.first - it->second.second); + erase(s2, it->second.first + it->second.second); + ms.erase(it); + } + if (ms.size() == 0) + puts("-1"); + else + printf("%d\n", max(calc(s1), calc(s2))); + } + putchar('\n'); + } + return 0; + } diff --git a/HDOJ/3491_autoAC.cpp b/HDOJ/3491_autoAC.cpp new file mode 100644 index 0000000..b961ca0 --- /dev/null +++ b/HDOJ/3491_autoAC.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAX=205; +const int inf=999999; +struct node +{ + int v,c,next; +}g[MAX*MAX]; +int adj[MAX],dis[MAX],cur[MAX],num[MAX],pre[MAX]; +int n,m,e,s,t,vn,S,H; +void add(int u,int v,int c) +{ + g[e].v=v; g[e].c=c; g[e].next=adj[u]; adj[u]=e++; + g[e].v=u; g[e].c=0; g[e].next=adj[v]; adj[v]=e++; +} +int sap() +{ + int i,u,v,flag,aug=inf+1,flow=0; + for(i=0;i<=vn;i++) + { + cur[i]=adj[i]; + num[i]=dis[i]=0; + } + num[0]=vn; + pre[s]=u=s; + while(dis[s] +#include +#include +#include +using namespace std; +#define maxN 300 +const double eps = 1e-8; +typedef struct +{ + double x,y; +}point; +point l[maxN*2]; +double direction(point p1,point p2, point p3) +{ + return (p3.x-p1.x)*(p2.y-p1.y)-(p2.x-p1.x)*(p3.y-p1.y); +} +bool online(point p1,point p2,point p3) +{ + return (min(p1.x,p2.x)<=p3.x&&p3.x<=max(p1.x,p2.x))&&(min(p1.y,p2.y)<=p3.y&&p3.y<=max(p1.y,p2.y)); +} +bool insect(point p1,point p2,point p3,point p4) +{ + double d3=direction(p1,p2,p3); + double d4=direction(p1,p2,p4); + if(d3*d4<0) + return true; + else if(d3==0) return true; + else if(d4==0) return true; + return false ; +} +int main() +{ + int cnt = 0; + int N,n,i,j,k; + bool flag; + scanf("%d",&N); + while(N--) + { + cnt ++; + scanf("%d",&n); + for(i=0;i<2*n-1;i+=2) + { + scanf("%lf%lf%lf%lf",&l[i].x,&l[i].y,&l[i+1].x,&l[i+1].y); + } + bool issame = true; + flag = false; + for(i=0;i< 2*n -1 && flag==false;i++) + for(j=i+1;j < 2*n && flag==false;j++) + { + if (fabs(l[i].x-l[j].x) <= eps && fabs(l[i].y-l[j].y) <= eps) + continue; + issame = false; + flag=true; + for(k=0;k<2*n-1;k+=2) + { + if(insect(l[i],l[j],l[k],l[k+1]) == false) + {flag=false; + break;} + } + } + if(flag==true || issame) + {printf("Yes\n");} + else printf("No\n"); + } + return 0; +} diff --git a/HDOJ/3493_autoAC.cpp b/HDOJ/3493_autoAC.cpp new file mode 100644 index 0000000..5ca2987 --- /dev/null +++ b/HDOJ/3493_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +using namespace std; +const int mod=9997; +int f[3][3],map[3][3]; +int t[3][3]={{5,-7,4},{1,0,0},{0,1,0}}; +int g[4][1]={1,2,6,19},n; +void multy_2(int v[][3],int u[][3]) +{ + int c[3][3]; + memset(c,0,sizeof(c)); + for(int i=0;i<3;i++) + { + for(int j=0;j<3;j++) + { + for(int k=0;k<3;k++) + { + c[i][j]=(c[i][j]+(v[i][k]*u[k][j]+mod)%mod+mod)%mod; + } + } + } + memcpy(v,c,sizeof(c)); +} +void multy_1(int k) +{ + for(;k>0;k=k>>1) + { + if(k & 1) multy_2(map,f); + multy_2(f,f); + } +} +void run() +{ + multy_1(n-4); + cout<<(g[3][0]*map[0][0]%mod+g[2][0]*map[0][1]%mod+g[1][0]*map[0][2]%mod)%mod< +#include +#include +using namespace std; +const int MAX = 999999; +int val[111],time[111],dp[111][1111]; +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + int n,m,l; + scanf("%d%d%d",&n,&m,&l); + int i,j,k; + for(i = 0; i=1; j--) + { + for(k = l; k>=time[i]; k--) + { + dp[j][k] = max(dp[j][k],dp[j-1][k-time[i]]+val[i]); + } + } + } + if(dp[m][l]<0) + dp[m][l] = 0; + printf("%d\n",dp[m][l]); + } + return 0; +} diff --git a/HDOJ/3497_autoAC.cpp b/HDOJ/3497_autoAC.cpp new file mode 100644 index 0000000..f0ce83c --- /dev/null +++ b/HDOJ/3497_autoAC.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#define IP 3.1415926 +using namespace std; +int main() +{ + double r, h; + while( scanf("%lf %lf", &h, &r) != EOF) + { + double ans = asin(0.01 * r / (4 * h)); + printf("%0.2lf\n", 180 * ans / IP); + } +} diff --git a/HDOJ/3498_autoAC.cpp b/HDOJ/3498_autoAC.cpp new file mode 100644 index 0000000..efe6f91 --- /dev/null +++ b/HDOJ/3498_autoAC.cpp @@ -0,0 +1,157 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const ll maxn = 105; +int T, n, m, x, y, t, tot, mp[maxn][maxn]; +inline void read(int &ret) +{ + char c; + do { + c = getchar(); + } while (c < '0' || c > '9'); + ret = c - '0'; + while ((c = getchar()) >= '0' && c <= '9') + ret = ret * 10 + (c - '0'); +} +struct DLX +{ +#define maxn 500005 +#define F(i,A,s) for (int i=A[s];i!=s;i=A[i]) + int L[maxn], R[maxn], U[maxn], D[maxn]; + int row[maxn], col[maxn], ans[maxn], cnt[maxn]; + int n, m, num, sz; + void add(int now, int l, int r, int u, int d, int x, int y) + { + L[now] = l; R[now] = r; U[now] = u; + D[now] = d; row[now] = x; col[now] = y; + } + void reset(int n, int m) + { + num = 0x7FFFFFFF; + this->n = n; this->m = m; + for (int i = 0; i <= m; i++) + { + add(i, i - 1, i + 1, i, i, 0, i); + cnt[i] = 0; + } + L[0] = m; R[m] = 0; sz = m + 1; + } + void insert(int x, int y) + { + int ft = sz - 1; + if (row[ft] != x) + { + add(sz, sz, sz, U[y], y, x, y); + U[D[sz]] = sz; D[U[sz]] = sz; + } + else + { + add(sz, ft, R[ft], U[y], y, x, y); + R[L[sz]] = sz; L[R[sz]] = sz; + U[D[sz]] = sz; D[U[sz]] = sz; + } + ++cnt[y]; ++sz; + } + void remove(int now) + { + R[L[now]] = R[now]; + L[R[now]] = L[now]; + F(i, D, now) F(j, R, i) + { + D[U[j]] = D[j]; + U[D[j]] = U[j]; + --cnt[col[j]]; + } + } + void resume(int now) + { + F(i, U, now) F(j, L, i) + { + D[U[j]] = j; + U[D[j]] = j; + ++cnt[col[j]]; + } + R[L[now]] = now; + L[R[now]] = now; + } + bool dfs(int x) + { + if (!R[0]) { num = min(num, x); return true; } + int now = R[0]; + F(i, R, 0) if (cnt[now]>cnt[i]) now = i; + remove(now); + F(i, D, now) + { + ans[x] = row[i]; + F(j, R, i) remove(col[j]); + if (dfs(x + 1)) return true; + F(j, L, i) resume(col[j]); + } + resume(now); + return false; + } + void Remove(int now) + { + F(i, D, now) + { + L[R[i]] = L[i]; + R[L[i]] = R[i]; + } + } + void Resume(int now) + { + F(i, U, now) L[R[i]] = R[L[i]] = i; + } + int vis[maxn]; + int flag[maxn]; + int A() + { + int dis = 0; + F(i, R, 0) vis[i] = 0; + F(i, R, 0) if (!vis[i]) + { + dis++; vis[i] = 1; + F(j, D, i) F(k, R, j) vis[col[k]] = 1; + } + return dis; + } + void Dfs(int x) + { + if (!R[0]) num = min(num, x); + else if (x + A()cnt[i]) now = i; + F(i, D, now) + { + Remove(i); F(j, R, i) Remove(j); + Dfs(x + 1); + F(j, L, i) Resume(j); Resume(i); + } + } + } +}dlx; +int main() +{ + while (scanf("%d%d", &n, &m) == 2) + { + memset(mp, 0, sizeof(mp)); + dlx.reset(n, n); + while (m--) + { + scanf("%d%d", &x, &y); + mp[x][y] = mp[y][x] = 1; + } + for (int i = 1; i <= n;i++) + for (int j = 1; j <= n;j++) + if (i == j || mp[i][j]) dlx.insert(i, j); + dlx.Dfs(0); + printf("%d\n", dlx.num); + } + return 0; +} diff --git a/HDOJ/3499_autoAC.cpp b/HDOJ/3499_autoAC.cpp new file mode 100644 index 0000000..769a8fc --- /dev/null +++ b/HDOJ/3499_autoAC.cpp @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef __int64 ll; +const int N=100010; +const int M=500010; +const ll inf=1LL<<60; +struct node +{ + int to; + ll dis; + node *next; +}E[M<<1],*G1[N],*G2[N],*head; +int n,m,num; +ll d1[N],d2[N]; +bool inq[N]; +map dict; +inline void add(int a,int b,ll c,node *G[]) +{ + head->to=b; + head->dis=c; + head->next=G[a]; + G[a]=head++; +} +inline int change(char *s) +{ + if(dict.count(s)) return dict[s]; + else return dict[s]=num++; +} +void SPFA(int s,ll d[],node *G[]) +{ + deque Q; + Q.push_back(s); + memset(inq,false,sizeof(inq)); + fill(d,d+N,inf); + d[s]=0; + int to; + ll dis; + while(!Q.empty()) + { + int u=Q.front(); + Q.pop_front(); + inq[u]=false; + for(node *p=G[u];p;p=p->next) + { + to=p->to; + dis=p->dis; + if(d[to]>d[u]+dis) + { + d[to]=d[u]+dis; + if(!inq[to]) + { + inq[to]=true; + if(!Q.empty() && d[to]<=d[Q.front()]) Q.push_front(to); + else Q.push_back(to); + } + } + } + } +} +int main() +{ + char s1[20],s2[20]; + while(~scanf("%d%d",&n,&m)) + { + num=0; + dict.clear(); + memset(G1,NULL,sizeof(G1)); + memset(G2,NULL,sizeof(G2)); + head=E; + int s,t; + ll dis; + for(int i=0;inext) + { + int j=p->to; + if(d1[i]dis)/2); + } + } + if(ans==inf) printf("-1\n"); + else printf("%I64d\n",ans); + } + return 0; +}