From a4744a8c1cfe5e86564e286136547978c25bdd17 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Tue, 13 Sep 2016 04:52:40 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 5200-5299 --- HDOJ/5200_autoAC.cpp | 75 +++++++++++++++ HDOJ/5201_autoAC.cpp | 55 +++++++++++ HDOJ/5202_autoAC.cpp | 55 +++++++++++ HDOJ/5203_autoAC.cpp | 49 ++++++++++ HDOJ/5204_autoAC.cpp | 122 ++++++++++++++++++++++++ HDOJ/5206_autoAC.cpp | 56 +++++++++++ HDOJ/5207_autoAC.cpp | 34 +++++++ HDOJ/5208_autoAC.cpp | 61 ++++++++++++ HDOJ/5209_autoAC.cpp | 61 ++++++++++++ HDOJ/5210_autoAC.cpp | 27 ++++++ HDOJ/5211_autoAC.cpp | 27 ++++++ HDOJ/5212_autoAC.cpp | 39 ++++++++ HDOJ/5213_autoAC.cpp | 83 ++++++++++++++++ HDOJ/5214_autoAC.cpp | 45 +++++++++ HDOJ/5215_autoAC.cpp | 86 +++++++++++++++++ HDOJ/5216_autoAC.cpp | 40 ++++++++ HDOJ/5217_autoAC.cpp | 178 ++++++++++++++++++++++++++++++++++ HDOJ/5218_autoAC.cpp | 45 +++++++++ HDOJ/5219_autoAC.cpp | 183 +++++++++++++++++++++++++++++++++++ HDOJ/5220_autoAC.cpp | 66 +++++++++++++ HDOJ/5221_autoAC.cpp | 222 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/5222_autoAC.cpp | 74 +++++++++++++++ HDOJ/5223_autoAC.cpp | 51 ++++++++++ HDOJ/5224_autoAC.cpp | 23 +++++ HDOJ/5225_autoAC.cpp | 103 ++++++++++++++++++++ HDOJ/5226_autoAC.cpp | 53 +++++++++++ HDOJ/5227_autoAC.cpp | 154 ++++++++++++++++++++++++++++++ HDOJ/5228_autoAC.cpp | 46 +++++++++ HDOJ/5229_autoAC.cpp | 47 +++++++++ HDOJ/5230_autoAC.cpp | 44 +++++++++ HDOJ/5232_autoAC.cpp | 63 ++++++++++++ HDOJ/5234_autoAC.cpp | 49 ++++++++++ HDOJ/5236_autoAC.cpp | 67 +++++++++++++ HDOJ/5237_autoAC.cpp | 55 +++++++++++ HDOJ/5238_autoAC.cpp | 111 ++++++++++++++++++++++ HDOJ/5239_autoAC.cpp | 125 ++++++++++++++++++++++++ HDOJ/5240_autoAC.cpp | 63 ++++++++++++ HDOJ/5241_autoAC.cpp | 65 +++++++++++++ HDOJ/5242_autoAC.cpp | 55 +++++++++++ HDOJ/5243_autoAC.cpp | 198 ++++++++++++++++++++++++++++++++++++++ HDOJ/5244_autoAC.cpp | 92 ++++++++++++++++++ HDOJ/5245_autoAC.cpp | 32 +++++++ HDOJ/5246_autoAC.cpp | 51 ++++++++++ HDOJ/5247_autoAC.cpp | 41 ++++++++ HDOJ/5248_autoAC.cpp | 77 +++++++++++++++ HDOJ/5249_autoAC.cpp | 54 +++++++++++ HDOJ/5251_autoAC.cpp | 173 +++++++++++++++++++++++++++++++++ HDOJ/5253_autoAC.cpp | 78 +++++++++++++++ HDOJ/5254_autoAC.cpp | 2 + HDOJ/5255_autoAC.cpp | 85 +++++++++++++++++ HDOJ/5256_autoAC.cpp | 29 ++++++ HDOJ/5258_autoAC.cpp | 122 ++++++++++++++++++++++++ HDOJ/5259_autoAC.cpp | 76 +++++++++++++++ HDOJ/5260_autoAC.cpp | 79 +++++++++++++++ HDOJ/5261_autoAC.cpp | 129 +++++++++++++++++++++++++ HDOJ/5262_autoAC.cpp | 59 ++++++++++++ HDOJ/5264_autoAC.cpp | 28 ++++++ HDOJ/5265_autoAC.cpp | 46 +++++++++ HDOJ/5268_autoAC.cpp | 20 ++++ HDOJ/5269_autoAC.cpp | 88 +++++++++++++++++ HDOJ/5270_autoAC.cpp | 66 +++++++++++++ HDOJ/5272_autoAC.cpp | 55 +++++++++++ HDOJ/5273_autoAC.cpp | 28 ++++++ HDOJ/5274_autoAC.cpp | 130 +++++++++++++++++++++++++ HDOJ/5275_autoAC.cpp | 54 +++++++++++ HDOJ/5276_autoAC.cpp | 32 +++++++ HDOJ/5277_autoAC.cpp | 91 ++++++++++++++++++ HDOJ/5278_autoAC.cpp | 82 ++++++++++++++++ HDOJ/5279_autoAC.cpp | 108 +++++++++++++++++++++ HDOJ/5280_autoAC.cpp | 50 ++++++++++ HDOJ/5281_autoAC.cpp | 49 ++++++++++ HDOJ/5282_autoAC.cpp | 62 ++++++++++++ HDOJ/5283_autoAC.cpp | 144 ++++++++++++++++++++++++++++ HDOJ/5284_autoAC.cpp | 51 ++++++++++ HDOJ/5285_autoAC.cpp | 91 ++++++++++++++++++ HDOJ/5286_autoAC.cpp | 176 ++++++++++++++++++++++++++++++++++ HDOJ/5288_autoAC.cpp | 124 ++++++++++++++++++++++++ HDOJ/5289_autoAC.cpp | 55 +++++++++++ HDOJ/5290_autoAC.cpp | 172 +++++++++++++++++++++++++++++++++ HDOJ/5291_autoAC.cpp | 59 ++++++++++++ HDOJ/5292_autoAC.cpp | 53 +++++++++++ HDOJ/5293_autoAC.cpp | 74 +++++++++++++++ HDOJ/5294_autoAC.cpp | 187 ++++++++++++++++++++++++++++++++++++ HDOJ/5295_autoAC.cpp | 130 +++++++++++++++++++++++++ HDOJ/5296_autoAC.cpp | 156 ++++++++++++++++++++++++++++++ HDOJ/5297_autoAC.cpp | 60 ++++++++++++ HDOJ/5298_autoAC.cpp | 45 +++++++++ HDOJ/5299_autoAC.cpp | 76 +++++++++++++++ 88 files changed, 6876 insertions(+) create mode 100644 HDOJ/5200_autoAC.cpp create mode 100644 HDOJ/5201_autoAC.cpp create mode 100644 HDOJ/5202_autoAC.cpp create mode 100644 HDOJ/5203_autoAC.cpp create mode 100644 HDOJ/5204_autoAC.cpp create mode 100644 HDOJ/5206_autoAC.cpp create mode 100644 HDOJ/5207_autoAC.cpp create mode 100644 HDOJ/5208_autoAC.cpp create mode 100644 HDOJ/5209_autoAC.cpp create mode 100644 HDOJ/5210_autoAC.cpp create mode 100644 HDOJ/5211_autoAC.cpp create mode 100644 HDOJ/5212_autoAC.cpp create mode 100644 HDOJ/5213_autoAC.cpp create mode 100644 HDOJ/5214_autoAC.cpp create mode 100644 HDOJ/5215_autoAC.cpp create mode 100644 HDOJ/5216_autoAC.cpp create mode 100644 HDOJ/5217_autoAC.cpp create mode 100644 HDOJ/5218_autoAC.cpp create mode 100644 HDOJ/5219_autoAC.cpp create mode 100644 HDOJ/5220_autoAC.cpp create mode 100644 HDOJ/5221_autoAC.cpp create mode 100644 HDOJ/5222_autoAC.cpp create mode 100644 HDOJ/5223_autoAC.cpp create mode 100644 HDOJ/5224_autoAC.cpp create mode 100644 HDOJ/5225_autoAC.cpp create mode 100644 HDOJ/5226_autoAC.cpp create mode 100644 HDOJ/5227_autoAC.cpp create mode 100644 HDOJ/5228_autoAC.cpp create mode 100644 HDOJ/5229_autoAC.cpp create mode 100644 HDOJ/5230_autoAC.cpp create mode 100644 HDOJ/5232_autoAC.cpp create mode 100644 HDOJ/5234_autoAC.cpp create mode 100644 HDOJ/5236_autoAC.cpp create mode 100644 HDOJ/5237_autoAC.cpp create mode 100644 HDOJ/5238_autoAC.cpp create mode 100644 HDOJ/5239_autoAC.cpp create mode 100644 HDOJ/5240_autoAC.cpp create mode 100644 HDOJ/5241_autoAC.cpp create mode 100644 HDOJ/5242_autoAC.cpp create mode 100644 HDOJ/5243_autoAC.cpp create mode 100644 HDOJ/5244_autoAC.cpp create mode 100644 HDOJ/5245_autoAC.cpp create mode 100644 HDOJ/5246_autoAC.cpp create mode 100644 HDOJ/5247_autoAC.cpp create mode 100644 HDOJ/5248_autoAC.cpp create mode 100644 HDOJ/5249_autoAC.cpp create mode 100644 HDOJ/5251_autoAC.cpp create mode 100644 HDOJ/5253_autoAC.cpp create mode 100644 HDOJ/5254_autoAC.cpp create mode 100644 HDOJ/5255_autoAC.cpp create mode 100644 HDOJ/5256_autoAC.cpp create mode 100644 HDOJ/5258_autoAC.cpp create mode 100644 HDOJ/5259_autoAC.cpp create mode 100644 HDOJ/5260_autoAC.cpp create mode 100644 HDOJ/5261_autoAC.cpp create mode 100644 HDOJ/5262_autoAC.cpp create mode 100644 HDOJ/5264_autoAC.cpp create mode 100644 HDOJ/5265_autoAC.cpp create mode 100644 HDOJ/5268_autoAC.cpp create mode 100644 HDOJ/5269_autoAC.cpp create mode 100644 HDOJ/5270_autoAC.cpp create mode 100644 HDOJ/5272_autoAC.cpp create mode 100644 HDOJ/5273_autoAC.cpp create mode 100644 HDOJ/5274_autoAC.cpp create mode 100644 HDOJ/5275_autoAC.cpp create mode 100644 HDOJ/5276_autoAC.cpp create mode 100644 HDOJ/5277_autoAC.cpp create mode 100644 HDOJ/5278_autoAC.cpp create mode 100644 HDOJ/5279_autoAC.cpp create mode 100644 HDOJ/5280_autoAC.cpp create mode 100644 HDOJ/5281_autoAC.cpp create mode 100644 HDOJ/5282_autoAC.cpp create mode 100644 HDOJ/5283_autoAC.cpp create mode 100644 HDOJ/5284_autoAC.cpp create mode 100644 HDOJ/5285_autoAC.cpp create mode 100644 HDOJ/5286_autoAC.cpp create mode 100644 HDOJ/5288_autoAC.cpp create mode 100644 HDOJ/5289_autoAC.cpp create mode 100644 HDOJ/5290_autoAC.cpp create mode 100644 HDOJ/5291_autoAC.cpp create mode 100644 HDOJ/5292_autoAC.cpp create mode 100644 HDOJ/5293_autoAC.cpp create mode 100644 HDOJ/5294_autoAC.cpp create mode 100644 HDOJ/5295_autoAC.cpp create mode 100644 HDOJ/5296_autoAC.cpp create mode 100644 HDOJ/5297_autoAC.cpp create mode 100644 HDOJ/5298_autoAC.cpp create mode 100644 HDOJ/5299_autoAC.cpp diff --git a/HDOJ/5200_autoAC.cpp b/HDOJ/5200_autoAC.cpp new file mode 100644 index 0000000..553d138 --- /dev/null +++ b/HDOJ/5200_autoAC.cpp @@ -0,0 +1,75 @@ +#include +#include +#include +#include +using namespace std; +#define M 500005 +struct point{ + int i, v; +}p[M]; +struct node +{ + int v; + int cur; +}s[M]; +int has[M], res[M]; +bool cmp (point a, point b) +{ + return a.v > b.v; +} +int S() +{ + int ret=0,ok=0; + char c; + while((c=getchar())) + { + if(c>='0'&&c<='9') + ret=(ret<<3)+ret+ret+c-'0',ok=1; + else if(ok) + return ret; + } + return ret; +} +bool cmp2(node a,node b) +{ + return a.v= 0; j--) + { + for ( ; i < n; i++) + { + if (p[i].v <= s[j].v) + break; + int id = p[i].i; + has[id] = 1; + if (!has[id-1] && !has[id+1]) ++ans; + else if (has[id-1] && has[id+1]) --ans; + } + res[s[j].cur] = ans; + } + for (i = 0; i < d; i++) + { + printf ("%d\n", res[i]); + } + } + return 0; +} diff --git a/HDOJ/5201_autoAC.cpp b/HDOJ/5201_autoAC.cpp new file mode 100644 index 0000000..6286a34 --- /dev/null +++ b/HDOJ/5201_autoAC.cpp @@ -0,0 +1,55 @@ +#include +typedef long long LL; +#define mod 1000000007 +LL pow(LL a, LL b) { + LL s = 1; + while(b) { + if(b&1) s = (s * a) % mod; + a = (a*a) % mod; + b >>= 1; + } + return s; +} +LL f[200005],inv[200005]; +void init() +{ + f[0]=f[1]=inv[0]=inv[1]=1; + for(LL i=2;i<=200000;++i){ + f[i]=f[i-1]*i%mod; + inv[i]=pow(f[i],mod-2); + } +} +LL C(int n,int m) +{ + if(m>n||m<0) return 0; + return f[n]*inv[m]%mod*inv[n-m]%mod; +} +LL n,m; +LL cal(int x) +{ + LL ans=0; + for(LL i=0,s=x;i +#include +const int N = 1005; +char str[N]; +int n, pos[N], num, len, cnt; +bool judge() { + for (int i = 0, j = len - 1; i < len; i++, j--) + if (str[i] != str[j]) + return false; + return true; +} +int main() { + while (scanf("%d", &n) == 1) { + scanf("%s", str); + num = 0; + len = strlen(str); + for (int i = 0; i < len; i++) { + if (str[i] == '?') { + str[i] = 'a'; + pos[num++] = i; + } + } + if (num == 0 && !judge()) { + printf("%s\n", str); + continue; + } + if (num == 0 && judge() || len == 1) { + printf("QwQ\n"); + continue; + } + if (len & 1) { + if (!judge()) { + printf("%s\n", str); + continue; + } + bool flag = judge(); + if (flag && pos[num - 1] != len / 2) { + str[pos[num - 1]] = 'b'; + printf("%s\n", str); + } + else if (flag && pos[num - 1] == len / 2 && num == 1) + printf("QwQ\n"); + else if (flag && pos[num - 1] == len / 2 && num > 1) { + str[pos[num - 2]] = 'b'; + printf("%s\n", str); + } + } + else { + if (judge()) + str[pos[num - 1]] = 'b'; + printf("%s\n", str); + } + } + return 0; +} diff --git a/HDOJ/5203_autoAC.cpp b/HDOJ/5203_autoAC.cpp new file mode 100644 index 0000000..0d14c1e --- /dev/null +++ b/HDOJ/5203_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +using namespace std; +int l,r,x,n,m; +int ok(int a,int b,int c) +{ + if(aa) return true; + else return false; +} +long long calc2(int x,int y) +{ + long long tot=0; + for(int i=1;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define mem0(a) memset(a, 0, sizeof(a)) +#define lson l, m, rt << 1 +#define rson m + 1, r, rt << 1 | 1 +#define define_m int m = (l + r) >> 1 +#define rep0(a, b) for (int a = 0; a < (b); a++) +#define rep1(a, b) for (int a = 1; a <= (b); a++) +#define all(a) (a).begin(), (a).end() +#define lowbit(x) ((x) & (-(x))) +#define constructInt4(name, a, b, c, d) name(int a = 0, int b = 0, int c = 0, int d = 0): a(a), b(b), c(c), d(d) {} +#define constructInt3(name, a, b, c) name(int a = 0, int b = 0, int c = 0): a(a), b(b), c(c) {} +#define constructInt2(name, a, b) name(int a = 0, int b = 0): a(a), b(b) {} +#define pchr(a) putchar(a) +#define pstr(a) printf("%s", a) +#define sint(a) ReadInt(a) +#define sint2(a, b) ReadInt(a);ReadInt(b) +#define sint3(a, b, c) ReadInt(a);ReadInt(b);ReadInt(c) +#define pint(a) WriteInt(a) +typedef double db; +typedef long long LL; +typedef pair pii; +typedef multiset msi; +typedef set si; +typedef vector vi; +typedef map mii; +const int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1}; +const int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1}; +const int maxn = 1e3 + 7; +const int maxm = 1e5 + 7; +const int maxv = 1e7 + 7; +const int max_val = 1e6 + 7; +const int MD = 1e9 +7; +const int INF = 1e9 + 7; +const double PI = acos(-1.0); +const double eps = 1e-10; +templateT gcd(T a, T b){return b==0?a:gcd(b,a%b);} +templatevoid ReadInt(T &x){char c=getchar();while(!isdigit(c))c=getchar();x=0;while(isdigit(c)){x=x*10+c-'0';c=getchar();}} +templatevoid WriteInt(T i) {int p=0;static int b[20];if(i == 0) b[p++] = 0;else while(i){b[p++]=i%10;i/=10;}for(int j=p-1;j>=0;j--)pchr('0'+b[j]);} +struct abc { + pii a[100007]; + int l, r; + void Init() { l = r = 0; } + void push_back(int x) { + a[r++] = make_pair(x, 0); + for(int i = l; i < r - 1; i++) a[i].second++; + if (r - l >= 62) { + int pos; + for (int i = l; i < r; i++) { + if (a[i].second == 61) { + pos = i; + break; + } + } + for (int i = pos; i > l; i--) a[i] = a[i - 1]; + l++; + } + int p = r - 1; + while (p > l && a[p].first < a[p - 1].first) { + swap(a[p], a[p - 1]); + p--; + } + } + pii &operator [] (int i) { + return a[l + i]; + } + int size() { + return r - l; + } +}; +abc g; +LL calc(LL x, LL pos) { + if (x < pos) return 0; + return (x - pos) / pos / 2 + 1; +} +int main() { + int n; + while (cin >> n) { + g.Init(); + rep0(i, n) { + int id, w; + sint(id); + if (id == 1) { + sint(w); + g.push_back(w); + } + else { + LL L, R, k; + sint3(L, R, k); + int sz = g.size(); + rep0(i, sz) { + LL pos = 1LL << g[i].second, c = calc(R, pos) - calc(L - 1, pos); + if (k <= c) { + pint(g[i].first); + pchr('\n'); + break; + } + k -= c; + } + } + } + } + return 0; +} diff --git a/HDOJ/5206_autoAC.cpp b/HDOJ/5206_autoAC.cpp new file mode 100644 index 0000000..76d613d --- /dev/null +++ b/HDOJ/5206_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 0x7fffffff +using namespace std; +typedef long long LL; +const LL maxn=10000+10; +LL n,m; +struct Point +{ + LL x,y,z; + Point (LL x=0,LL y=0,LL z=0):x(x),y(y),z(z){} +}a,b,c,d; +typedef Point Vector; +double Dot(Vector A,Vector B) {return A.x*B.x + A.y*B.y; } +double Length(Vector A) {return sqrt(Dot(A,A)); } +double angle(Vector A,Vector B) {return acos(Dot(A,B)/Length(A)/Length(B)); } +LL dis(Point A,Point B) +{ + LL xx=(A.x-B.x)*(A.x-B.x); + LL yy=(A.y-B.y)*(A.y-B.y); + LL zz=(A.z-B.z)*(A.z-B.z); + return xx+yy+zz; +} +int main() +{ + int t,ncase=1; + scanf("%d",&t); + while (t--) + { + scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d", + &a.x,&a.y,&a.z,&b.x,&b.y,&b.z,&c.x,&c.y,&c.z,&d.x,&d.y,&d.z); + int flag=0; + LL len,len2,len3; + len=dis(a,b) ;len2=dis(a,c) ;len3=dis(a,d) ; + if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3)) + flag++; + len=dis(b,a) ;len2=dis(b,c) ;len3=dis(b,d) ; + if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3)) + flag++; + len=dis(c,a) ;len2=dis(c,b) ;len3=dis(c,d) ; + if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3)) + flag++; + len=dis(d,a) ;len2=dis(d,b) ;len3=dis(d,c) ; + if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3)) + flag++; + if (flag==4) printf("Case #%d: Yes\n",ncase++); + else printf("Case #%d: No\n",ncase++); + } + return 0; +} diff --git a/HDOJ/5207_autoAC.cpp b/HDOJ/5207_autoAC.cpp new file mode 100644 index 0000000..34d53a3 --- /dev/null +++ b/HDOJ/5207_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#include +#include +#define maxn 100000+5 +using namespace std; +int mapp[maxn],head[maxn]; +int n; +int main() +{ + cin.sync_with_stdio(false); + int t,casee=1; + cin>>t; + while(t--) + { + cin>>n; + memset(mapp,0,sizeof(mapp)); + memset(head,0,sizeof(head)); + int maxx=-1; + for(int i=0;i>x;mapp[x]++;maxx=max(maxx,x);} + for(int i=2;i<=maxx;i++) + { + for(int j=i;j<=maxx;j+=i) + { + if(mapp[j]) head[i]+=mapp[j]; + } + } + cout<<"Case #"<=1;i--) + { + if(head[i]>=2) {cout< +#include +#include +#include +using namespace std; +typedef long long LL; +int _,ans; +int state(int i,int l,int r) +{ + if((1 << i) <= l)return 1; + else if((1 << i) > r)return 0; + else return -1; +} +void deal(int & l,int & r,int v,int i) +{ + l = max(l - v,0); + r = min(max(r - v,0),(1 << i) - 1); +} +void dfs(int l1,int r1,int l2,int r2,int i,int cur) +{ + if(l2 <= l1 && r1 <= r2 || i == -1)return; + if(cur + ((LL)1 << (i + 1)) - 1 < ans)return; + int st1 = state(i,l1,r1),st2 = state(i,l2,r2); + if(st1 >= 0 && st2 >= 0) + { + cur |= ((st1 ^ st2) << i); + ans = max(cur,ans); + deal(l1,r1,st1 << i,i) , deal(l2,r2,st2 << i,i); + dfs(l1,r1,l2,r2,i - 1,cur); + } + else if(st1 == -1 && st2 == -1) + { + dfs(l1,min(r1,(1 << i) - 1),l2,min(r2,(1 << i) - 1),i - 1,cur); + deal(l1,r1,1 << i,i) , deal(l2,r2,1 << i,i); + dfs(l1,r1,l2,r2,i - 1,cur); + } + else if(st1 >= 0 && st2 == -1) + { + deal(l1,r1,st1 << i,i) , deal(l2,r2,st1 << i,i); + dfs(l1,r1,l2,r2,i - 1,cur); + } + else// if(st1 == -1 && st2 >= 0) + { + cur |= (1 << i); + ans = max(cur,ans); + deal(l1,r1,!st2 << i,i) , deal(l2,r2,st2 << i,i); + dfs(l1,r1,l2,r2,i - 1,cur); + } +} +int main() +{ + scanf("%d",&_); + for(int kcas = 1;kcas <= _;kcas++) + { + int l1,l2,r1,r2; + scanf("%d%d%d%d",&l1,&r1,&l2,&r2); + ans = 0; + dfs(l1,r1,l2,r2,30,0); + printf("Case #%d: %d\n",kcas,ans); + } +} diff --git a/HDOJ/5209_autoAC.cpp b/HDOJ/5209_autoAC.cpp new file mode 100644 index 0000000..b88c2d1 --- /dev/null +++ b/HDOJ/5209_autoAC.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +using namespace std; +const int mod=1000000007; +const int maxn=110005; +typedef long long LL; +LL jie[maxn],jie2[maxn]; +int mm(int n,int m){ + LL s=1,k=n; + while(m>0){ + if(m&1){ + s=s*k; + s%=mod; + } + k=k*k; + k%=mod; + m>>=1; + } + return s; +} +int zuhe(int n,int m){ + LL s; + s=jie[n]; + s=s*jie2[m]; + s%=mod; + s=s*jie2[n-m]; + s%=mod; + return s; +} +void init(void){ + int i; + jie[0]=1; + jie2[0]=1; + for(i=1;i<=110000;i++){ + jie[i]=jie[i-1]*i; + jie[i]%=mod; + jie2[i]=mm(jie[i],mod-2); + } +} +LL dp[1005]; +int main() +{ + int i,j,n,m,t,N=0; + cin>>t; + init(); + while(t--){ + cin>>n>>m; + memset(dp,0,sizeof(dp)); + dp[0]=1; + for(i=1;i<=n;i++){ + for(j=1;j<=i;j++){ + dp[i]+=zuhe(i-1,j-1)*((dp[i-j]*zuhe(j+m-1,m-1))%mod); + dp[i]%=mod; + } + } + printf("Case #%d: %d\n",++N,dp[n]); + } +} diff --git a/HDOJ/5210_autoAC.cpp b/HDOJ/5210_autoAC.cpp new file mode 100644 index 0000000..11d4c4c --- /dev/null +++ b/HDOJ/5210_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +#define maxn 100+5 +using namespace std; +int mapp[maxn]; +int main() +{ + int n; + while(cin>>n) + { + int sum=0; + memset(mapp,0,sizeof(mapp)); + for(int i=0;i>x; + if(!mapp[x]) sum++; + mapp[x]++; + } + int k; + cin>>k; + k-=(n-sum); + if(k<=0) cout< +#include +#include +#include +using namespace std; +#define MAXN 10005 +int num[MAXN],n,f[MAXN]; +int main() +{ + while(scanf("%d",&n) != EOF) + { + int ans = 0; + memset(f,0,sizeof(f)); + for(int i = 0;i < n;i++) + scanf("%d",&num[i]); + for(int i = n - 1;i >= 0;i--) + { + ans += f[num[i]]; + int q = sqrt(num[i] + 1) + 1; + for(int j = 1;j <= q && j <= num[i];j++) + if(num[i] % j == 0) + f[j] = i + 1, + f[num[i] / j] = i + 1; + } + printf("%d\n",ans); + } +} diff --git a/HDOJ/5212_autoAC.cpp b/HDOJ/5212_autoAC.cpp new file mode 100644 index 0000000..e9aea60 --- /dev/null +++ b/HDOJ/5212_autoAC.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +typedef long long LL; +int dp[11111]; +int num[11111]; +int sum[11111]; +int n; +int main() +{ + while(scanf("%d", &n) != EOF) + { + int maxnum = 0, ans = 0; + memset(sum, 0, sizeof(sum)); + for(int i = 0; i < n; i ++) + { + scanf("%d", &num[i]); + sum[num[i]] ++; + maxnum = maxnum < num[i] ? num[i] : maxnum; + } + memset(dp, 0, sizeof(dp)); + for(int i = 2; i <= maxnum; i ++) + { + for(int j = i; j <= maxnum; j += i) + { + dp[i] += sum[j]; + } + dp[i] *= dp[i]; + } + for(int i = maxnum; i >= 2; i --) + { + for(int j = i + i; j <= maxnum; j += i) + dp[i] -= dp[j]; + ans = (ans + (LL)i * (i - 1) * dp[i]) % 10007; + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/5213_autoAC.cpp b/HDOJ/5213_autoAC.cpp new file mode 100644 index 0000000..5bc53f4 --- /dev/null +++ b/HDOJ/5213_autoAC.cpp @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define N 30005 +int a[N]; +int n,k,m; +int len,tot; +int l1,l2,r1,r2; +int ans[N],c[N*2]; +struct node{ + int l,r,id,p; + void set(int i,int ll,int rr,int pp){ + id=i;l=ll;r=rr;p=pp; + } +}f[N*4]; +bool cmp(node a,node b){ + if(a.l/len!=b.l/len) return a.l/lenf[i].l){ + nl--; + if(k>a[nl]) res+=c[k-a[nl]]; + c[a[nl]]++; + } + while(nra[nr]) res+=c[k-a[nr]]; + c[a[nr]]++; + } + while(nla[nl]) res-=c[k-a[nl]]; + c[a[nl]]--; + nl++; + } + while(nr>f[i].r){ + if(k>a[nr]) res-=c[k-a[nr]]; + c[a[nr]]--; + nr--; + } + ans[f[i].id]+=res*f[i].p; + } +} +int main() +{ + while(~scanf("%d",&n)){ + scanf("%d",&k); + for(int i=1;i<=n;i++) + { + scanf("%d",&a[i]); + } + memset(c,0,sizeof(c)); + scanf("%d",&m); + tot=0; + for(int i=1;i<=m;i++) + { + ans[i]=0; + scanf("%d%d%d%d",&l1,&r1,&l2,&r2); + f[tot++].set(i,l1,r2,1); + f[tot++].set(i,l1,l2-1,-1); + f[tot++].set(i,r1+1,r2,-1); + if(r1+1<=l2-1) f[tot++].set(i,r1+1,l2-1,1); + } + len=sqrt(n); + sort(f,f+tot,cmp); + solve(); + for(int i=1;i<=m;i++) + printf("%d\n",ans[i]); + } + return 0; +} diff --git a/HDOJ/5214_autoAC.cpp b/HDOJ/5214_autoAC.cpp new file mode 100644 index 0000000..f6e6d25 --- /dev/null +++ b/HDOJ/5214_autoAC.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int INF = (1<<30)-1; +const int mod=4294967296; +const int maxn=10000005; +unsigned int l[maxn],r[maxn]; +int main(){ + int T; + scanf("%d",&T); + while(T--){ + memset(l,0,sizeof(l)); + memset(r,0,sizeof(r)); + unsigned int n,a,b,c,d; + cin>>n>>l[1]>>r[1]>>a>>b>>c>>d; + for(int i=2;i<=n;i++) l[i]=l[i-1]*a+b; + for(int i=2;i<=n;i++) r[i]=r[i-1]*c+d; + for(int i=1;i<=n;i++) + if(l[i]>r[i]) swap(l[i],r[i]); + int minn=r[1],maxx=l[1]; + for(int i=1;i<=n;i++){ + if(l[i]>maxx) maxx=l[i]; + if(r[i]minn&&r[i] +#include +#include +using namespace std; +const int maxn=200000+100; +struct Edge +{ + int v, nxt; + Edge(int v=0, int nxt=0):v(v), nxt(nxt) {} +} edge[600010]; +bool even, odd; +int n, m, head[maxn], color[maxn], tot, cnt, pre[maxn], bel[maxn]; +void init() +{ + tot=even=odd=0; + cnt=0; + memset(color, 0, sizeof color); + memset(head, -1, sizeof head); + memset(bel, -1, sizeof bel); +} +void AddEdge(int u, int v) +{ + edge[tot]=Edge(v, head[u]); + head[u]=tot++; +} +void dfs(int u, int fa) +{ + for(int i=head[u]; ~i; i=edge[i].nxt) + { + if((i^1)==fa)continue ; + int v=edge[i].v; + if(color[v]==color[u]) + { + odd=1; + ++cnt; + int x=v; + while(!even) + { + if(~bel[x]) + { + even=true; + break; + } + bel[x]=cnt; + x=pre[x]; + if(x==u || x==-1)break; + } + } + if(color[v]==3-color[u]) + even=1; + if(!color[v]) + { + color[v]=3-color[u]; + pre[v]=u; + dfs(v, i); + } + } +} +int main() +{ + int T; + scanf("%d", &T); + while(T--) + { + scanf("%d%d", &n, &m); + init(); + while(m--) + { + int u, v; + scanf("%d%d", &u, &v); + AddEdge(u, v); + AddEdge(v, u); + } + for(int i=1; i<=n; i++) + if(!color[i]) + { + color[i]=1; + pre[i]=-1; + dfs(i, -1); + } + puts(odd?"YES":"NO"); + puts(even?"YES":"NO"); + } + return 0; +} diff --git a/HDOJ/5216_autoAC.cpp b/HDOJ/5216_autoAC.cpp new file mode 100644 index 0000000..e7a8e05 --- /dev/null +++ b/HDOJ/5216_autoAC.cpp @@ -0,0 +1,40 @@ +#include +#include +#include +#include +using namespace std; +const int maxn=100010; +int N,M; +int A[maxn],B[maxn]; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d%d",&N,&M); + for(int i=1;i<=M;i++)scanf("%d",&A[i]); + for(int i=1;i<=M;i++)scanf("%d",&B[i]); + sort(A+1,A+1+M); + sort(B+1,B+1+M); + bool flag=true; + for(int i=1;i<=M;i++) + if(A[i]>B[i]){flag=false;break;} + if(!flag){printf("Stupid BrotherK!\n");} + else + { + int ans=max(A[1]-1,N-B[M]); + int last=0; + for(int i=1;i<=M;i++) + { + if(A[i]>last) + { + ans=max(ans,A[i]-last-1); + } + last=B[i]; + } + printf("%.6lf\n",double(ans)); + } + } + return 0; +} diff --git a/HDOJ/5217_autoAC.cpp b/HDOJ/5217_autoAC.cpp new file mode 100644 index 0000000..eb0227f --- /dev/null +++ b/HDOJ/5217_autoAC.cpp @@ -0,0 +1,178 @@ +#include +#include +#include +using namespace std; +#define N 200010 +char str[N]; +struct Node +{ + Node(int l=0,int r=0){lnum=l;rnum=r;} + int lnum,rnum; +}node[N<<2]; +void pushup(int rt) +{ + int matched=min(node[rt<<1].lnum,node[rt<<1|1].rnum); + node[rt].lnum=node[rt<<1].lnum+node[rt<<1|1].lnum-matched; + node[rt].rnum=node[rt<<1].rnum+node[rt<<1|1].rnum-matched; +} +void build(int l,int r,int rt) +{ + if(l==r) + { + node[rt].lnum=node[rt].rnum=0; + if(str[l]=='(')node[rt].lnum=1; + else node[rt].rnum=1; + return ; + } + int mid=(l+r)/2; + build(l,mid,rt<<1); + build(mid+1,r,rt<<1|1); + pushup(rt); +} +Node query(int L,int R,int l,int r,int rt) +{ + if(L<=l&&r<=R) + return node[rt]; + int mid=(l+r)/2; + Node ret; + if(L<=mid)ret=query(L,R,l,mid,rt<<1); + if(R>mid) + { + Node tmp=query(L,R,mid+1,r,rt<<1|1); + int matched=min(ret.lnum,tmp.rnum); + ret.lnum+=tmp.lnum-matched; + ret.rnum+=tmp.rnum-matched; + } + return ret; +} +void change(int x,int l,int r,int rt) +{ + if(l==r&&r==x) + { + swap(node[rt].lnum,node[rt].rnum); + return; + } + int mid=(l+r)/2; + if(x<=mid)change(x,l,mid,rt<<1); + else change(x,mid+1,r,rt<<1|1); + pushup(rt); + return; +} +int lsearch(int L,int R,int K,Node &Val,int l,int r,int rt) +{ + if(L<=l&&r<=R) + { + int mid=(l+r)/2; + if(l==r) + { + int matched=min(Val.lnum,node[rt].rnum); + int lnum=Val.lnum+node[rt].lnum-matched; + int rnum=Val.rnum+node[rt].rnum-matched; + if(rnum==K)return l; + else + { + Val.lnum=lnum; + Val.rnum=rnum; + return 0; + } + } + int matched=min(Val.lnum,node[rt<<1].rnum); + int lnum=Val.lnum+node[rt<<1].lnum-matched; + int rnum=Val.rnum+node[rt<<1].rnum-matched; + if(K<=rnum) + { + return lsearch(L,R,K,Val,l,mid,rt<<1); + } + else + { + Val.lnum=lnum; + Val.rnum=rnum; + return lsearch(L,R,K,Val,mid+1,r,rt<<1|1); + } + } + int mid=(l+r)/2; + if(R<=mid)return lsearch(L,R,K,Val,l,mid,rt<<1); + if(L>mid)return lsearch(L,R,K,Val,mid+1,r,rt<<1|1); + int ret=lsearch(L,R,K,Val,l,mid,rt<<1); + if(ret)return ret; + else return lsearch(L,R,K,Val,mid+1,r,rt<<1|1); +} +int rsearch(int L,int R,int K,Node &Val,int l,int r,int rt) +{ + if(L<=l&&r<=R) + { + int mid=(l+r)/2; + if(l==r) + { + int matched=min(Val.rnum,node[rt].lnum); + int lnum=Val.lnum+node[rt].lnum-matched; + int rnum=Val.rnum+node[rt].rnum-matched; + if(lnum==K)return l; + else + { + Val.lnum=lnum; + Val.rnum=rnum; + return 0; + } + } + int matched=min(Val.rnum,node[rt<<1|1].lnum); + int lnum=Val.lnum+node[rt<<1|1].lnum-matched; + int rnum=Val.rnum+node[rt<<1|1].rnum-matched; + if(K<=lnum) + { + return rsearch(L,R,K,Val,mid+1,r,rt<<1|1); + } + else + { + Val.lnum=lnum; + Val.rnum=rnum; + return rsearch(L,R,K,Val,l,mid,rt<<1); + } + } + int mid=(l+r)/2; + if(R<=mid)return rsearch(L,R,K,Val,l,mid,rt<<1); + if(L>mid)return rsearch(L,R,K,Val,mid+1,r,rt<<1|1); + int ret=rsearch(L,R,K,Val,mid+1,r,rt<<1|1); + if(ret)return ret; + else return rsearch(L,R,K,Val,l,mid,rt<<1); +} +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + int n,q; + scanf("%d%d",&n,&q); + scanf(" %s",&str[1]); + int len=strlen(&str[1]); + build(1,len,1); + for(int i=0;i +#include +#include +#include +using namespace std; +int arr[300]; +int n,m; +int dp[300][300]; +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + scanf("%d%d",&n,&m); + for(int i=0;ij)dp[i][j]=dp[i-1][i-1-((arr[k]-1)%i-j)]; + if(dp[i][j])break; + } + } + } + int ok=1,ans=0; + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double eps(1e-8); +typedef long long lint; +#define ws Ws +#define rank rrrank +const int maxn = 100200 + 1; +int prime[maxn], vis[maxn], mu[maxn]; +int tot; +void Mobius(){ + mu[1] = 1; + for( int i = 2 ; i < maxn ; i ++ ){ + if( !vis[i] ) + prime[++tot] = i, mu[i] = -1; + for( int j = 1 ; j <= tot && i * prime[j] < maxn ; j ++ ){ + vis[i*prime[j]] = 1; + if( i % prime[j] == 0 ){ + mu[i*prime[j]] = 0; + break; + } + else + mu[i*prime[j]] = - mu[i]; + } + } + return; +} +int wa[maxn], wb[maxn], wv[maxn], ws[maxn]; +int cmp(int *r, int a, int b, int l) +{ + return r[a] == r[b] && r[a + l] == r[b + l]; +} +void da(int *r, int *sa, int n, int m) +{ + int *x = wa, *y = wb, *t, i, j, p; + for(i = 0; i < m; i++) ws[i] = 0; + for(i = 0; i < n; i++) ws[x[i] = r[i]]++; + for(i = 1; i < m; i++) ws[i] += ws[i - 1]; + for(i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i; + for(j = 1, p = 1; p < n; j <<= 1, m = p) + { + for(p = 0, i = n - j; i < n; i++) y[p++] = i; + for(i = 0; i < n; i++) if(sa[i] >= j) y[p++] = sa[i] - j; + for(i = 0; i < n; i++) wv[i] = x[y[i]]; + for(i = 0; i < m; i++) ws[i] = 0; + for(i = 0; i < n; i++) ws[wv[i]]++; + for(i = 1; i < m; i++) ws[i] += ws[i - 1]; + for(i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i]; + for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++) + x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++; + } + return; +} +int rank[maxn], height[maxn]; +void calheight(int *r, int *sa, int n) +{ + int i, j, k = 0; + for(i = 1; i <= n; i++) rank[sa[i]] = i; + for(i = 0; i < n; height[rank[i++]] = k) + for(k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; k++); + return; +} +int rank2[maxn], height2[maxn]; +void calheight2(int *r, int *sa, int n) +{ + int i, j, k = 0; + for(i = 1; i <= n; i++) rank2[sa[i]] = i; + for(i = 0; i < n; height2[rank2[i++]] = k) + for(k ? k-- : 0, j = sa[rank2[i] - 1]; r[i + k] == r[j + k]; k++); + return; +} +int dp[maxn][20]; +void initRMQ(int n) +{ + for(int i = 1; i <= n; i++) dp[i][0] = height[i]; + for(int j = 1; (1 << j) <= n; j++) + for(int i = 1; i + (1 << j) - 1 <= n; i++) + dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]); + return; +} +int dp2[maxn][20]; +void initRMQ2(int n) +{ + for(int i = 1; i <= n; i++) dp2[i][0] = height2[i]; + for(int j = 1; (1 << j) <= n; j++) + for(int i = 1; i + (1 << j) - 1 <= n; i++) + dp2[i][j] = min(dp2[i][j - 1], dp2[i + (1 << (j - 1))][j - 1]); + return; +} +int askRMQ(int a, int b) +{ + int ra = rank[a], rb = rank[b]; + if(ra > rb) swap(ra, rb); + int k = 0; + while((1 << (k + 1)) <= rb - ra) k++; + return min(dp[ra + 1][k], dp[rb - (1 << k) + 1][k]); +} +int len; +int askRMQ2(int a, int b) +{ + a = len - a - 1; + b = len - b - 1; + int ra = rank2[a], rb = rank2[b]; + if(ra > rb) swap(ra, rb); + int k = 0; + while((1 << (k + 1)) <= rb - ra) k++; + return min(dp2[ra + 1][k], dp2[rb - (1 << k) + 1][k]); +} +char in[maxn]; +int s[maxn], sa[maxn]; +int main() +{ + Mobius(); + int T; + scanf("%d", &T); + while(T--) + { + scanf("%s", in); + len = strlen(in); + for(int i = 0; i < len; i++) + s[i] = in[i] - 'a' + 1; + s[len] = 0; + da(s, sa, len + 1, 28); + calheight(s, sa, len); + initRMQ(len); + for(int i = 0; i < len; i++) + s[i] = in[len - 1 - i] - 'a' + 1; + s[len] = 0; + da(s, sa, len + 1, 28); + calheight2(s, sa, len); + initRMQ2(len); + lint ans = 0; + for(int L = 1; L <= (len >> 1); L++) + { + int n = len; + int blocks = n / L + (n % L != 0); + int now = 1; + while(now < blocks) + { + if(now + 1 < blocks) + { + int len2 = askRMQ2((now + 1)*L - 1, now*L - 1); + int len1 = askRMQ(now*L, (now + 1)*L); + int totlen = L + len2 + len1; + int cnt = totlen / L; + for(int i = 2; i <= cnt; i++) + { + ans += mu[i]*(totlen - L*i + 1); + } + now = now + (len1 / L) + 1; + } + else + { + if(n % L != 0) break; + int totlen = (len - now*L) + askRMQ2(len - 1, now*L - 1); + int cnt = totlen / L; + for(int i = 2; i <= cnt; i++) + ans += mu[i]*(totlen - L*i + 1); + now = blocks; + } + } + } + printf("%I64d\n", (lint)len*(len + 1LL) / 2LL + ans); + } + return 0; +} diff --git a/HDOJ/5220_autoAC.cpp b/HDOJ/5220_autoAC.cpp new file mode 100644 index 0000000..7f0dc9d --- /dev/null +++ b/HDOJ/5220_autoAC.cpp @@ -0,0 +1,66 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +#pragma comment(linker, "/STACK:102400000,102400000") +#define pb push_back +#define mp make_pair +#define F first +#define S second +const int N = 33; +int f[N], c[N], m[N], d[N], w[N]; +vector a[N], b[N]; +typedef pair pii; +map g[2]; +map:: iterator it; +int main() { + int n, T; + scanf("%d", &T); + while (T--) { + scanf("%d", &n); + for (int i = 1; i <= 32; ++i) a[i].clear(), b[i].clear(); + memset(w, 0, sizeof(w)); + memset(d, 0, sizeof(d)); + g[0].clear(), g[1].clear(); + for (int i = 0; i < n; ++i) { + scanf("%d%d%d", &f[i], &c[i], &m[i]); + a[f[i]].pb(i), b[c[i]].pb(i); + } + bool ok = 1; + int mask = 0, cnt = 0; + for (int i = 1; i <= 32; ++i) { + if (b[i].size() == 1) { + if (d[f[b[i][0]]]) ok = 0; + mask ^= m[b[i][0]]; + d[f[b[i][0]]] = 1; + } + else if (b[i].size() > 1) w[i] = cnt++; + } + if (!ok) { + puts("0"); + continue; + } + int now = 0; + g[now].insert(mp(mp(0, 0), 1)); + for (int i = 1; i <= 32; ++i) { + if (!a[i].size() || d[i]) continue; + g[now ^ 1] = g[now]; + for (it = g[now].begin(); it != g[now].end(); it++) { + pii st = it -> F; + LL d = it -> S; + for (int j = 0; j < a[i].size(); ++j) { + int t = a[i][j]; + pii tmp = mp(st.F ^ m[t], st.S | (1 << w[c[t]])); + g[now ^ 1][tmp] += d; + } + } + now ^= 1; + } + printf("%I64d\n", g[now][mp(mask, (1 << cnt) - 1)]); + } + return 0; +} diff --git a/HDOJ/5221_autoAC.cpp b/HDOJ/5221_autoAC.cpp new file mode 100644 index 0000000..0bc91d2 --- /dev/null +++ b/HDOJ/5221_autoAC.cpp @@ -0,0 +1,222 @@ +#pragma comment(linker, "/STACK:102400000,102400000") +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define L(x) (x*2) +#define R(x) (x*2 + 1) +using namespace std; +const int INF = 0x3f3f3f3f ; +const int MX = 100000 + 5 ; +int n ,m ,num ,idx ,sum ; +int dep[MX] ,top[MX] ,V[MX] ,ti[MX] ,to[MX] ,head[MX] ,father[MX] ,siz[MX] ,son[MX] ; +struct Edge +{ + int v ,next ; +}E[MX*2] ; +void add_edge(int u ,int v) +{ + E[num].v = v ; E[num].next = head[u] ; head[u] = num++ ; + E[num].v = u ; E[num].next = head[v] ; head[v] = num++ ; +} +void dfs_find(int u ,int fa) +{ + dep[u] = dep[fa] + 1 ; + father[u] = fa ; + siz[u] = 1 ; + son[u] = 0 ; + for(int i = head[u] ;i != -1 ; i = E[i].next) + { + int v = E[i].v ; + if(v == fa) continue ; + dfs_find(v ,u) ; + siz[u] += siz[v] ; + if(siz[son[u]] < siz[v]) son[u] = v ; + } +} +void dfs_time(int u ,int fa) +{ + ti[u] = idx++ ; + top[u] = fa ; + if(son[u]) dfs_time(son[u] ,top[u]) ; + for(int i = head[u] ;i != -1 ;i = E[i].next) + { + int v = E[i].v ; + if(v == father[u] || v == son[u]) continue ; + dfs_time(v ,v) ; + } + to[u] = idx-1 ; +} +void init() +{ + sum = 0 ; + num = 0 ; + memset(head ,-1 ,sizeof(head)) ; +} +struct node +{ + int le ,rt ,sum ,flag ; +}T[MX*4] ; +void build(int x ,int le ,int rt) +{ + T[x].sum = 0 ; + T[x].flag = true ; + T[x].le = le ; T[x].rt = rt ; + if(le == rt) + return ; + int Mid = (le + rt)>>1 ; + build(L(x) ,le ,Mid) ; + build(R(x),Mid+1 ,rt) ; +} +void push_up(int x) +{ + T[x].sum = T[L(x)].sum + T[R(x)].sum ; + T[x].flag = true ; +} +void push_down(int x) +{ + if(!T[x].flag) + { + T[L(x)].sum = T[R(x)].sum = 0 ; + T[L(x)].flag = T[R(x)].flag = false ; + T[x].sum = 0 ; + } +} +bool Findpos(int x ,int pos) +{ + if(T[x].le == T[x].rt && T[x].le == pos) + { + if(!T[x].flag) T[x].sum = 0 ; + return T[x].flag ; + } + push_down(x) ; + int Mid = (T[x].le + T[x].rt)>>1 ; + if(pos <= Mid) return Findpos(L(x) ,pos) ; + else return Findpos(R(x) ,pos) ; + push_up(x) ; +} +void insert(int x ,int pos ,int w) +{ + if(T[x].le == T[x].rt && T[x].le == pos) + { + T[x].sum = w ; + T[x].flag = true ; + return ; + } + push_down(x) ; + int Mid = (T[x].le + T[x].rt)>>1 ; + if(pos <= Mid) insert(L(x) ,pos ,w) ; + else insert(R(x) ,pos ,w) ; + push_up(x) ; +} +void update(int x ,int Le ,int Rt) +{ + if(T[x].le == Le && T[x].rt == Rt) + { + T[x].flag = false ; + T[x].sum = 0 ; + return ; + } + push_down(x) ; + int Mid = (T[x].le + T[x].rt)>>1 ; + if(Le > Mid) update(R(x) ,Le ,Rt) ; + else if(Rt <= Mid) update(L(x) ,Le ,Rt) ; + else + { + update(L(x) ,Le ,Mid) ; + update(R(x) ,Mid+1 ,Rt) ; + } + push_up(x) ; +} +int Query(int x ,int Le ,int Rt) +{ + if(T[x].le == Le && T[x].rt == Rt) + { + if(!T[x].flag) T[x].sum = 0 ; + int temp = T[x].sum ; + T[x].sum = 0 ; + T[x].flag = false ; + return temp ; + } + push_down(x) ; + int Mid = (T[x].le + T[x].rt)>>1 ; + if(Le > Mid) return Query(R(x) ,Le ,Rt) ; + else if(Rt <= Mid) return Query(L(x) ,Le ,Rt) ; + else + return Query(L(x) ,Le ,Mid) + Query(R(x) ,Mid+1 ,Rt) ; +} +void LCA(int u ,int v) +{ + int temp ; + while(top[u] != top[v]) + { + if(dep[top[u]] < dep[top[v]]) + swap(u ,v) ; + temp = Query(1 ,ti[top[u]] ,ti[u]) ; + update(1 ,ti[top[u]] ,ti[u]) ; + sum += temp ; + u = father[top[u]] ; + } + if(dep[u] > dep[v]) + swap(u ,v) ; + temp = Query(1 ,ti[u] ,ti[v]) ; + update(1 ,ti[u] ,ti[v]) ; + sum += temp ; +} +int main() +{ + int Tx ,u ,v ; + scanf("%d" ,&Tx) ; + while(Tx--) + { + init() ; + scanf("%d" ,&n) ; + for(int i = 1 ;i <= n ; ++i) + scanf("%d" ,&V[i]) ; + for(int i = 1 ;i < n ; ++i) + { + scanf("%d%d" ,&u ,&v) ; + add_edge(u ,v) ; + } + dep[1] = siz[0] = 0 ; + dfs_find(1 ,1) ; + idx = 1 ; + dfs_time(1 ,1) ; + build(1 ,1 ,n) ; + for(int i = 1 ;i <= n ; ++i) + insert(1 ,ti[i] ,V[i]) ; + scanf("%d" ,&m) ; + int type ; + for(int i = 0 ;i < m ; ++i) + { + scanf("%d%d" ,&type ,&u) ; + if(type == 1) + { + scanf("%d" ,&v) ; + LCA(u ,v) ; + } + else if(type == 2) + { + bool flag = Findpos(1 ,ti[u]) ; + if(!flag) + { + insert(1 ,ti[u] ,V[u]) ; + sum -= V[u] ; + } + } + else if(type == 3) + { + sum += Query(1 ,ti[u] ,to[u]) ; + update(1 ,ti[u] ,to[u]) ; + } + cout< +#include +#include +#include +using namespace std; +#pragma comment(linker, "/STACK:102400000,102400000") +const int maxn = 1000005; +int N,M1,M2,cnt; +int fa[maxn],vis[maxn]; +vectorG[maxn]; +int find_father(int u){ + return u == fa[u] ? u : fa[u] = find_father(fa[u]); +} +void init(){ + for(int i = 1; i <= N; i++) fa[i] = i; + for(int i = 1; i <= N; i++) G[i].clear(); +} +bool dfs(int v){ + vis[v] = -1; + for(int i = 0; i < G[v].size(); i++){ + int e = G[v][i]; + if(vis[e] < 0) return false; + if(!vis[e] && !dfs(e)) return false; + } + vis[v] = 1; + return true; +} +int solve(){ + memset(vis,0,sizeof(vis)); + for(int i = 1; i <= N; i++){ + int e = find_father(i); + if(!vis[e]){ + if(!dfs(e)) return true; + } + } + return false; +} +int main(){ + int T; + scanf("%d",&T); + while(T--){ + scanf("%d%d%d",&N,&M1,&M2); + int u,v,ok = 0; + init(); + getchar(); + for(int i = 0; i < M1; i++){ + scanf("%d%d",&u,&v); + int f1 = find_father(u); + int f2 = find_father(v); + if(f1 == f2) + ok = 1; + else + fa[f1] = f2; + } + for(int i = 0; i < M2; i++){ + scanf("%d%d",&u,&v); + if(!ok){ + int f1 = find_father(u); + int f2 = find_father(v); + G[f1].push_back(f2); + } + } + if(ok) + printf("YES\n"); + else{ + ok = solve(); + if(ok) + printf("YES\n"); + else + printf("NO\n"); + } + } + return 0; +} diff --git a/HDOJ/5223_autoAC.cpp b/HDOJ/5223_autoAC.cpp new file mode 100644 index 0000000..7eaffdc --- /dev/null +++ b/HDOJ/5223_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 1005; +int T, n, m, l[maxn], r[maxn], ans[maxn], x[maxn]; +int gcd(int x, int y) +{ + if (x%y) return gcd(y, x%y); + return y; +} +int main() +{ + scanf("%d", &T); + while (T--) + { + scanf("%d%d", &n, &m); + for (int i = 1; i <= n; i++) x[i] = 1; + int F = 1; + for (int i = 1; i <= m; i++) + { + scanf("%d%d%d", &l[i], &r[i], &ans[i]); + for (int j = l[i]; j <= r[i]; j++) + { + x[j] = x[j] / gcd(ans[i], x[j]); + if ((double)x[j] * ans[i] > 1e9) F = 0; + x[j] = x[j] * ans[i]; + } + } + if (F) + for (int i = 1, u; i <= m; i++) + { + u = x[l[i]]; + for (int j = l[i]; j <= r[i]; j++) u = gcd(u, x[j]); + if (u != ans[i]) { F = 0; break; } + } + if (F) + { + for (int i = 1; i < n; i++) printf("%d ", x[i]); + printf("%d\n", x[n]); + } + else printf("Stupid BrotherK!\n"); + } + return 0; +} diff --git a/HDOJ/5224_autoAC.cpp b/HDOJ/5224_autoAC.cpp new file mode 100644 index 0000000..3f5e303 --- /dev/null +++ b/HDOJ/5224_autoAC.cpp @@ -0,0 +1,23 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int T, n; +int main() +{ + scanf("%d", &T); + while (T--) + { + scanf("%d", &n); + int k = sqrt(1.0*n), ans = 0x7FFFFFFF; + for (int i = 1; i <= k; i++) + if (n%i == 0) ans = min(ans, 2 * (i + n / i)); + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/5225_autoAC.cpp b/HDOJ/5225_autoAC.cpp new file mode 100644 index 0000000..6f27798 --- /dev/null +++ b/HDOJ/5225_autoAC.cpp @@ -0,0 +1,103 @@ +#include +#include +using namespace std; +#define mod 1000000007 +#define llt long long +llt cal[110],a[110],A[110]; +llt tree[330]; +template +inline char read(T &n){ + T x = 0, tmp = 1; char c = getchar(); + while((c < '0' | c > '9') && c != '-' && c != EOF) c = getchar(); + if(c == '-') c = getchar(), tmp = -1; + while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar(); + n = x*tmp; + return c; +} +template +inline void write(T n) { + if(n < 0) { + putchar('-'); + n = -n; + } + int len = 0,data[20]; + while(n) { + data[len++] = n%10; + n /= 10; + } + if(!len) data[len++] = 0; + while(len--) putchar(data[len]+48); +} +void create(llt l,llt r,llt rt) +{ + tree[rt]=0; + if(l==r) return; + llt mid=(l+r)>>1; + create(l,mid,rt<<1); + create(mid+1,r,rt<<1|1); +} +llt query(llt ll,llt rr,llt l,llt r,llt rt) +{ + if(l==ll&&r==rr) return tree[rt]; + llt mid=(l+r)>>1; + if(rr<=mid) return query(ll,rr,l,mid,rt<<1); + else if(ll>mid) return query(ll,rr,mid+1,r,rt<<1|1); + else + { + llt ans=query(ll,mid,l,mid,rt<<1); + ans+=query(mid+1,rr,mid+1,r,rt<<1|1); + return ans; + } +} +void update(llt l,llt r,llt rt,llt x) +{ + if(l==x&&r==x) + { + tree[rt]++; + return; + } + llt mid=(l+r)>>1; + if(x<=mid) update(l,mid,rt<<1,x); + else update(mid+1,r,rt<<1|1,x); + tree[rt]=tree[rt<<1]+tree[rt<<1|1]; +} +void init() +{ + cal[0]=0,cal[1]=0,cal[2]=1; + A[1]=1;A[0]=1; + for(int i=2;i<=100;i++) + {A[i]=(A[i-1]*i)%mod; + } + for(int i=3;i<=100;i++) + { + cal[i]=((i*cal[i-1])%mod+(i*(i-1)*A[i-1]/2)%mod)%mod; + } +} +llt sum(llt x) +{ + return ((x-1)*x)/2; +} +int main() +{ + init();llt n; + while(scanf("%I64d",&n)!=EOF) + { + llt ans=0; + llt i,j,pre=0,tmp=0; + llt k; + create(1,100,1); + for(i=1;i<=n;i++) + { + read(a[i]); + tmp=query(a[i]+1>100?100:a[i]+1,100,1,100,1); + j=n-i-(n-a[i]-tmp); + if(j<=0) continue; + k=A[n-i];llt p=cal[n-i]; + ans=(ans+((p*j)%mod+(pre*k*j)%mod+(sum(j)*k)%mod)%mod)%mod; + update(1,100,1,a[i]); + pre+=j; + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/5226_autoAC.cpp b/HDOJ/5226_autoAC.cpp new file mode 100644 index 0000000..d6d5f4e --- /dev/null +++ b/HDOJ/5226_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +using namespace std; +#define maxn 101000 +#define ll long long +ll A[maxn],inv[maxn]; +ll mod; +ll Pow(ll a,ll b) +{ + ll ret=1; + a%=mod; + while(b) + { + if(b&1) ret=ret*a%mod; + a=a*a%mod; + b>>=1; + } + return ret%mod; +} +void init() +{ + A[0]=1,A[1]=1; + inv[1]=1;inv[0]=1; + for(int i=2;ix&&yy>xx&&y>xx) {printf("0\n");continue;} + if(y>x) x=y; + if(yy>xx) yy=xx; + ll st=x,en=xx,h=y; + while(h<=yy&&st<=en) + { + if(st +#include +#include +#include +using namespace std ; +typedef long long LL ; +#define clr( a , x ) memset ( a , x , sizeof a ) +#define cpy( a , x ) memcpy ( a , x , sizeof a ) +const int MAXN = 10005 ; +const int MAXE = 20005 ; +struct Edge { + int v , n ; + Edge () {} + Edge ( int v , int n ) : v ( v ) , n ( n ) {} +} ; +Edge E[MAXE] ; +int H[MAXN] , cntE ; +int phi[MAXN] ; +LL val[MAXN] ; +LL S[MAXN] , top ; +LL ct[MAXN] ; +int ans ; +int n ; +int Q[MAXN] , head , tail ; +map < LL , int > mp ; +int vis[MAXN] ; +int siz[MAXN] ; +int pre[MAXN] ; +int gcd ( int a , int b ) { + return b ? gcd ( b , a % b ) : a ; +} +void init () { + ans = 0 ; + cntE = 0 ; + clr ( H , -1 ) ; + clr ( vis , 0 ) ; +} +void addedge ( int u , int v ) { + E[cntE] = Edge ( v , H[u] ) ; + H[u] = cntE ++ ; +} +LL get ( int n , int m ) { + LL res = 0 ; + if ( n > m ) swap ( n , m ) ; + for ( int i = 1 , j ; i <= n ; i = j + 1 ) { + j = min ( n / ( n / i ) , m / ( m / i ) ) ; + res += ( LL ) ( phi[j] - phi[i - 1] ) * ( n / i ) * ( m / i ) ; + } + return res ; +} +void preprocess () { + for ( int i = 0 ; i <= 10000 ; ++ i ) { + phi[i] = i ; + } + for ( int i = 2 ; i <= 10000 ; ++ i ) if ( phi[i] == i ) { + for ( int j = i ; j <= 10000 ; j += i ) { + phi[j] = phi[j] / i * ( i - 1 ) ; + } + } + for ( int i = 2 ; i <= 10000 ; ++ i ) { + phi[i] += phi[i - 1] ; + } + for ( int t = 1 ; t <= 10000 ; ++ t ) { + ct[t] = get ( t , t ) + ct[t - 1] ; + } +} +int get_root ( int s ) { + head = tail = 0 ; + Q[tail ++] = s ; + pre[s] = 0 ; + while ( head != tail ) { + int u = Q[head ++] ; + for ( int i = H[u] ; ~i ; i = E[i].n ) { + int v = E[i].v ; + if ( vis[v] || v == pre[u] ) continue ; + pre[v] = u ; + Q[tail ++] = v ; + } + } + int root_siz = tail , root = s ; + while ( head ) { + int u = Q[-- head] , cnt = 1 ; + siz[u] = 1 ; + for ( int i = H[u] ; ~i ; i = E[i].n ) { + int v = E[i].v ; + if ( vis[v] || v == pre[u] ) continue ; + siz[u] += siz[v] ; + if ( siz[v] > cnt ) cnt = siz[v] ; + } + cnt = max ( cnt , tail - siz[u] ) ; + if ( cnt < root_ ) { + root_siz = cnt ; + root = u ; + } + } + return root ; +} +void get_val ( int u , int f , LL value ) { + S[top ++] = value ; + for ( int i = H[u] ; ~i ; i = E[i].n ) { + int v = E[i].v ; + if ( vis[v] || v == f ) continue ; + get_val ( v , u , value ^ val[v] ) ; + } +} +void dfs ( int u ) { + int root = get_root ( u ) ; + vis[root] = 1 ; + mp.clear () ; + if ( !val[root] ) ++ ans ; + for ( int i = H[root] ; ~i ; i = E[i].n ) { + int v = E[i].v ; + if ( vis[v] ) continue ; + top = 0 ; + get_val ( v , root , val[v] ) ; + for ( int j = 0 ; j < top ; ++ j ) { + map < LL , int > :: iterator it = mp.find ( S[j] ^ val[root] ) ; + if ( it != mp.end () ) ans += it->second * 2 ; + if ( !( S[j] ^ val[root] ) ) ans += 2 ; + } + for ( int j = 0 ; j < top ; ++ j ) { + mp[S[j]] ++ ; + } + } + for ( int i = H[root] ; ~i ; i = E[i].n ) { + int v = E[i].v ; + if ( vis[v] ) continue ; + dfs ( v ) ; + } +} +void solve () { + int t , a , b , c ; + init () ; + for ( int i = 1 ; i < n ; ++ i ) { + scanf ( "%d%d" , &a , &b ) ; + addedge ( a , b ) ; + addedge ( b , a ) ; + } + for ( int i = 1 ; i <= n ; ++ i ) { + scanf ( "%d%d%d%d" , &t , &a , &b , &c ) ; + val[i] = ct[t - 1] + c - 1 ; + val[i] += get ( a - 1 , t ) ; + val[i] += get ( a , b - 1 ) - get ( a - 1 , b - 1 ) ; + } + dfs ( 1 ) ; + ans = n * n - ans ; + int x = gcd ( n * n , ans ) ; + printf ( "%d/%d\n" , ans / x , n * n / x ) ; +} +int main () { + preprocess () ; + while ( ~scanf ( "%d" , &n ) ) solve () ; + return 0 ; +} diff --git a/HDOJ/5228_autoAC.cpp b/HDOJ/5228_autoAC.cpp new file mode 100644 index 0000000..93f266f --- /dev/null +++ b/HDOJ/5228_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include +using namespace std; +int has[13*4]; +char s[5]; +int main() +{ + int t; + cin>>t; + while(t--) + { + memset(has,0,sizeof(has)); + for(int i=0;i<5;i++) + { + scanf("%s",s); + int cur; + if(strlen(s)==3) + { + cur=(s[1]-'0')*10+s[2]-'0'; + } + else + { + cur=s[1]-'0'; + } + cur--; + has[cur*4+s[0]-'A']++; + } + int ans=5; + for(int i=0;i<10;i++) + { + for(int j=0;j<4;j++) + { + int cnt=5; + for(int k=0;k<5;k++) + { + int num=(i+k)*4+j; + if(has[num%(52)]) cnt--; + } + ans=min(ans,cnt); + } + } + printf("%d\n",ans); + } +} diff --git a/HDOJ/5229_autoAC.cpp b/HDOJ/5229_autoAC.cpp new file mode 100644 index 0000000..4356c4d --- /dev/null +++ b/HDOJ/5229_autoAC.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +ll gcd(ll a,ll b){ + for(;a>0&&b>0;a>b?a%=b:b%=a); + return a+b; +} +int main(){ + int T; + while(scanf("%d",&T)!=EOF){ + while(T--){ + int n; + scanf("%d",&n); + mapm; + ll ji=0,ou=0; + m.clear(); + int i; + for(i=1;i<=n;i++){ + string a; + cin>>a; + m[a]++; + if(a.length()%2){ + ji++; + } + else ou++; + } + ll cnt=0; + cnt=ji*ou; + for(map::iterator it=m.begin();it!=m.end();it++){ + if(it->second>1){ + cnt+=((it->second)*((it->second)-1)/2); + } + } + ll sum=n*(n-1)/2; + if(cnt==0)printf("0/1\n"); + else{ + ll g=gcd(cnt,sum); + printf("%lld/%lld\n",cnt/g,sum/g); + } + } + } + return 0; +} diff --git a/HDOJ/5230_autoAC.cpp b/HDOJ/5230_autoAC.cpp new file mode 100644 index 0000000..a7c4cf6 --- /dev/null +++ b/HDOJ/5230_autoAC.cpp @@ -0,0 +1,44 @@ +#include +#include +#include +#define MOD 998244353 +using namespace std; +int Now[101005][2],Next[101005][2],s[101005]; +void add(int &x,int y) +{ + if (y>MOD) y-=MOD; + x+=y; + if (x>MOD) x-=MOD; +} +int main() +{ + int i,j,T,c,n,l,r; + memset(s,0,sizeof(s)); + Next[1][1]=1; + for (i=1;i<=450;i++) + { + for (j=1;j<=100000;j++) + { + Now[j][0]=Next[j][0]; Next[j][0]=0; + Now[j][1]=Next[j][1]; Next[j][1]=0; + } + for (j=i;j<=100000;j++) + { + add(Now[j+i][0],Now[j][0]+Now[j][1]); + add(Next[j+1][1],Now[j][0]); + } + for (j=1;j<=100000;j++) add(s[j],Now[j][0]+Now[j][1]); + } + s[0]=1; + for (i=1;i<=100000;i++) add(s[i],s[i-1]); + scanf("%d",&T); + while (T--) + { + scanf("%d%d%d%d",&n,&c,&l,&r); + l-=c; r-=c; c=s[r]; + if (l!=0) c=s[r]-s[l-1]; + if (c<0) c+=MOD; + printf("%d\n",c); + } + return 0; +} diff --git a/HDOJ/5232_autoAC.cpp b/HDOJ/5232_autoAC.cpp new file mode 100644 index 0000000..1a7b6b4 --- /dev/null +++ b/HDOJ/5232_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 200001 +#define mod 10007 +#define eps 1e-9 +int Num; +char CH[20]; +const int inf=0x3f3f3f3f; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +inline void P(int x) +{ + Num=0;if(!x){putchar('0');puts("");return;} + while(x>0)CH[++Num]=x%10,x/=10; + while(Num)putchar(CH[Num--]+48); + puts(""); +} +int g[300][300]; +int main() +{ + int n; + while(scanf("%d",&n)!=EOF) + { + memset(g,0,sizeof(g)); + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#define Max 2147483647 +#define INF 0x7fffffff +#define N 110 +#define ll long long +#define mem(a,b) memset(a,b,sizeof(a)) +#define repu(i, a, b) for(int i = (a); i < (b); i++) +const double PI=-acos(-1.0); +using namespace std; +int dp[N][N][N]; +int w[N][N]; +int main() +{ + int n,m,k; + while(~scanf("%d%d%d",&n,&m,&k)) + { + repu(i,0,1+n) + repu(j,0,m+1) + repu(p,0,k+1) + dp[i][j][p] = 0; + repu(i,1,1+n) + repu(j,1,1+m) + scanf("%d",&w[i][j]); + repu(i,1,n+1) + { + repu(j,1,m+1) + { + for(int p = w[i][j]; p<=k; p++) + { + int t = max(dp[i-1][j][p],dp[i][j-1][p]); + int s = max(dp[i-1][j][p-w[i][j]]+w[i][j],dp[i][j-1][p-w[i][j]]+w[i][j]); + dp[i][j][p] = max(t,s); + } + } + } + int maxn = 0; + repu(p,0,k+1) + maxn = max(dp[n][m][p],maxn); + printf("%d\n",maxn); + } + return 0; +} diff --git a/HDOJ/5236_autoAC.cpp b/HDOJ/5236_autoAC.cpp new file mode 100644 index 0000000..3207330 --- /dev/null +++ b/HDOJ/5236_autoAC.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +using namespace std; +const int MAXN = 100005; +const int MAXS = 30; +int N, X, S; +double P, F[MAXS]; +void CalcF(){ + int i; + double a = 1, b = 1. / (P - 1.); + S = numeric_limits::max(); + F[0] = 0.; + F[1] = - b / a; + for(i = 2; i <= N && i <= S; i ++){ + a = (a - P) / (1 - P); + b = (b - 1) / (1 - P); + F[i] = - b / a; + if(F[i] > F[i >> 1] + F[i - (i >> 1)] + X){ + F[i] = F[i >> 1] + F[i - (i >> 1)] + X; + S = i; + } + } +} +double BFSolve(){ + static double dp[MAXN]; + int i, j; + dp[0] = 0; + for(i = 1; i <= N; i ++){ + if(i <= S){ + dp[i] = F[i] + X; + }else{ + dp[i] = numeric_limits::max(); + } + for(j = 1; j <= S && j < i; j ++){ + dp[i] = min(dp[i], dp[i - j] + dp[j]); + } + } + return dp[N]; +} +double Solve(){ + int i, a, b; + double ans = numeric_limits::max(); + if(N < S) + return F[N] + X; + for(i = 1; i <= S; i ++){ + a = N / i; + b = N % i; + if(a >= b && i < S){ + ans = min(ans, (a - b) * F[i] + b * F[i + 1] + a * X); + } + if(a + b + 1 >= i){ + ans = min(ans, (a + 1 - i + b) * F[i] + (i - b) * F[i - 1] + (a + 1) * X); + } + } + return ans; +} +int main(){ + int T, i; + scanf("%d", &T); + for(i = 1; i <= T; i ++){ + scanf("%d%lf%d", &N, &P, &X); + CalcF(); + printf("Case #%d: %.6lf\n", i, Solve()); + } + return 0; +} diff --git a/HDOJ/5237_autoAC.cpp b/HDOJ/5237_autoAC.cpp new file mode 100644 index 0000000..065f98d --- /dev/null +++ b/HDOJ/5237_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +using namespace std; +char S[1000],Q[1000]; +char Std[65]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +void Make(int x) +{ + Q[strlen(Q)]=Std[x]; +} +void f(int n) +{ + if(n) f(n/2); + else return; + printf("%d",n%2); +} +int main() +{ + int t,tm; + scanf("%d",&tm);t=tm; + while(t--) + { + int k,i,n; + scanf("%d %s",&n,S); + while(n--) + { + memset(Q,0,sizeof(Q)); + int l=strlen(S); + for(i=0;i +#include +#include +using namespace std ; +typedef long long LL ; +#define clr( a , x ) memset ( a , x , sizeof a ) +#define ls ( o << 1 ) +#define rs ( o << 1 | 1 ) +#define lson ls , l , m +#define rson rs , m + 1 , r +#define mid ( ( l + r ) >> 1 ) +#define root 1 , 1 , n +const int MAXN = 50005 ; +const int MOD = 29393 ; +int mod[4] = { 7 , 13 , 17 , 19 } ; +int p[4][20][MOD] ; +int f[MAXN << 2][4][20] ; +int n , m ; +void preprocess () { + for ( int i = 0 ; i < 4 ; ++ i ) { + for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) { + p[i][j][0] = 1 ; + for ( int k = 1 ; k < MOD ; ++ k ) { + p[i][j][k] = p[i][j][k - 1] * j % m ; + } + } + } +} +void upd ( int o , char op , int x ) { + for ( int i = 0 ; i < 4 ; ++ i ) { + for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) { + if ( op == '+' ) f[o][i][j] = ( j + x ) % m ; + else if ( op == '*' ) f[o][i][j] = ( j * x ) % m ; + else f[o][i][j] = p[i][j][x] ; + } + } +} +void push_up ( int o ) { + for ( int i = 0 ; i < 4 ; ++ i ) { + for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) { + f[o][i][j] = f[rs][i][f[ls][i][j]] ; + } + } +} +void build ( int o , int l , int r ) { + if ( l == r ) { + char c ; + int x ; + scanf ( " %c%d" , &c , &x ) ; + upd ( o , c , x ) ; + return ; + } + int m = mid ; + build ( lson ) ; + build ( rson ) ; + push_up ( o ) ; +} +void update ( int x , char c , int v , int o , int l , int r ) { + if ( l == r ) { + upd ( o , c , v ) ; + return ; + } + int m = mid ; + if ( x <= m ) update ( x , c , v , lson ) ; + else update ( x , c , v , rson ) ; + push_up ( o ) ; +} +int exgcd ( int a , int b , int &x , int &y ) { + if ( !b ) { + x = 1 ; + y = 0 ; + return a ; + } + int ans = exgcd ( b , a % b , y , x ) ; + y -= a / b * x ; + return ans ; +} +int crt ( int v ) { + int ans = 0 ; + for ( int i = 0 ; i < 4 ; ++ i ) { + int t = MOD / mod[i] , x , y ; + exgcd ( t , mod[i] , x , y ) ; + ans = ( ans + f[1][i][v % mod[i]] * t * ( x % mod[i] ) ) % MOD ; + } + return ( ans + MOD ) % MOD ; +} +void solve () { + int op , x , v ; + char c ; + scanf ( "%d%d" , &n , &m ) ; + build ( root ) ; + while ( m -- ) { + scanf ( "%d%d" , &op , &x ) ; + if ( op == 1 ) { + printf ( "%d\n" , crt ( x ) ) ; + } else { + scanf ( " %c%d" , &c , &v ) ; + update ( x , c , v , root ) ; + } + } +} +int main () { + int T ; + preprocess () ; + scanf ( "%d" , &T ) ; + for ( int i = 1 ; i <= T ; ++ i ) { + printf ( "Case #%d:\n" , i ) ; + solve () ; + } + return 0 ; +} diff --git a/HDOJ/5239_autoAC.cpp b/HDOJ/5239_autoAC.cpp new file mode 100644 index 0000000..1c0746c --- /dev/null +++ b/HDOJ/5239_autoAC.cpp @@ -0,0 +1,125 @@ +#include +#include +#include +#include +using namespace std; +typedef unsigned long long ull; +struct uint64{ + static const ull MODN = 9223372034707292160; + ull n; + uint64(ull n = 0):n(n){} + static uint64 ass(ull n){ + if(n >= MODN) + return uint64(n - MODN); + else + return uint64(n); + } + inline uint64 operator-() const{ + return uint64(MODN - n); + }; + friend inline uint64 operator*(const uint64& a, const uint64& b){ + uint64 tmp; + ull a1 = (a.n >> 32), a0 = (a.n & 0xffffffff); + ull b1 = (b.n >> 32), b0 = (b.n & 0xffffffff); + tmp = ass(a1 * b1); + tmp = tmp + ass(a1 * b0); + tmp = tmp + ass(a0 * b1); + for(int i = 0; i < 32; i ++) + tmp = tmp + tmp; + tmp = tmp + ass(a0 * b0); + return tmp; + } + friend inline uint64 operator+(const uint64& a, const uint64& b){ + ull n = a.n + b.n; + return uint64((n < a.n || n >= MODN) ? (n - MODN) : n); + } + friend inline uint64 operator-(const uint64& a, const uint64& b){ + return (a.n < b.n) ? (a.n + MODN - b.n) : (a.n - b.n); + } + inline uint64 sqr(){ + return (*this) * (*this); + } +}; +const int MAXN = 131072; +ull arr[MAXN]; +int N, M; +class Segtree{ +public: + static const int MAXK = 30; + struct NODE{ + int flg; + uint64 d[MAXK]; + }node[MAXN<<1]; + inline void popup(int id){ + int j; + for(j = 0; j < MAXK; j ++) + node[id].d[j] = node[id<<1].d[j] + node[id<<1|1].d[j]; + } + inline void shift(int id, int k){ + node[id].flg += k; + for(int j = 0; j <= MAXK - 2; j ++){ + node[id].d[j] = node[id].d[min(j + k, MAXK - 1)]; + } + } + inline void pushdown(int id){ + int flg = node[id].flg; + if(flg > 0){ + shift(id<<1, flg); + shift(id<<1|1, flg); + node[id].flg = 0; + } + } + void build(int id, int l, int r){ + int mid = (l + r) >> 1; + if(l == r){ + node[id].d[0] = uint64::ass(arr[l]); + node[id].flg = 0; + for(int j = 1; j < MAXK; j ++) + node[id].d[j] = node[id].d[j - 1].sqr(); + }else{ + node[id].flg = 0; + build(id<<1, l, mid); + build(id<<1|1, mid+1, r); + popup(id); + } + } + uint64 query(int id, int l, int r, int L, int R){ + uint64 ret; + if(l == L && r == R){ + ret = node[id].d[0]; + shift(id, 1); + return ret; + } + int mid = (L + R) >> 1; + pushdown(id); + if(l > mid){ + ret = query(id<<1|1, l, r, mid + 1, R); + }else if(r <= mid){ + ret = query(id<<1, l, r, L, mid); + }else{ + ret = query(id<<1, l, mid, L, mid) + query(id<<1|1, mid + 1, r, mid + 1, R); + } + popup(id); + return ret; + } +}tree; +int main(){ + int i, T, l, r; + uint64 ans; + scanf("%d", &T); + for(i = 1; i <= T; i ++){ + printf("Case #%d:\n", i); + scanf("%d%d", &N, &M); + for(l = 1; l <= N; l ++){ + scanf("%I64u", &arr[l]); + } + tree.build(1, 1, N); + ans = 0; + while(M --){ + scanf("%d%d", &l, &r); + ans = ans + tree.query(1, l, r, 1, N); + printf("%I64u\n", ans.n); + } + } + return 0; +} diff --git a/HDOJ/5240_autoAC.cpp b/HDOJ/5240_autoAC.cpp new file mode 100644 index 0000000..1a51771 --- /dev/null +++ b/HDOJ/5240_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int INF = 0x3f3f3f3f; +const double eps = 1e-4; +struct node +{ + long long r,s,l; +}exam[111111]; +bool cmp(node a,node b) +{ + return a.s0;i--) + exam[i].s-=(exam[i-1].s+exam[i-1].l); + int flag=1,i=0,j=0; + while(i +#include +#include +using namespace std; +int a[10000],b[10000],c[10000]; +void SP() +{ + memset(c,0,sizeof(c)); + int i,j; + for(i=1;i<=a[0];i++) + for(j=1;j<=b[0];j++) + c[i+j-1]+=a[i]*b[j]; + i=1; + for(i=1;i<9999;i++) + { + c[i+1]+=c[i]/10; + a[i]=c[i]%10; + if(a[i]) a[0]=i; + } +} +void PP() +{ + memset(c,0,sizeof(c)); + int i,j; + for(i=1;i<=b[0];i++) + for(j=1;j<=b[0];j++) + c[i+j-1]+=b[i]*b[j]; + i=1; + for(i=1;i<9999;i++) + { + c[i+1]+=c[i]/10; + b[i]=c[i]%10; + if(b[i]) b[0]=i; + } +} +int main() +{ + int t,tm; + scanf("%d",&t);tm=t; + while(t--) + { + int n; + scanf("%d",&n); + printf("Case #%d: ",tm-t); + if(!n) printf("1\n"); + else + { + n*=5; + memset(a,0,sizeof(a)); + memset(b,0,sizeof(b)); + a[0]=1;a[1]=1; + b[0]=1;b[1]=2; + while(n) + { + if(n%2) + SP(); + PP(); + n/=2; + } + for(int i=a[0];i;i--) printf("%d",a[i]); + printf("\n"); + } + } + return 0; +} diff --git a/HDOJ/5242_autoAC.cpp b/HDOJ/5242_autoAC.cpp new file mode 100644 index 0000000..8be8dd3 --- /dev/null +++ b/HDOJ/5242_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +#include +using namespace std; +#define LL __int64 +const int maxn=1e5+100; +vectorV[maxn]; +priority_queueQ; +LL a[maxn]; +LL dp[maxn]; +LL dfs(int cur){ + int i,v; + LL tmp; + dp[cur]=a[cur]; + for(i=0;itmp+a[cur]){ + Q.push(tmp); + }else{ + Q.push(dp[cur]-a[cur]); + dp[cur]=tmp+a[cur]; + } + } + return dp[cur]; +} +int main(){ + int t ,n,m,i,j,k,u,v,cnt=0; + LL ans; + scanf("%d",&t); + while(t--){ + scanf("%d%d",&n,&k); + for(i=1;i<=n;i++) + scanf("%lld",&a[i]); + for(i=1;i +#include +#include +#include +using namespace std; +#define V P +const double eps = 1e-6; +inline int dcmp (double x) { + return x < -eps ? -1 : x > eps; +} +struct P { + double x, y; + void scan() { + scanf("%lf%lf", &x, &y); + } + P(double _x = 0, double _y = 0) : x(_x), y(_y) { } + V operator + (V a) const { + return V(x + a.x, y + a.y); + } + V operator - (V a) const { + return V(x - a.x, y - a.y); + } + V operator * (double p) const { + return V(p * x, p * y); + } + V operator / (double p) const { + return V(x / p, y / p); + } + bool operator < (P a) const { + return x < a.x || (dcmp(x - a.x) == 0 && y < a.y); + } + bool operator == (P a) const { + return dcmp(x - a.x) == 0 && dcmp(y - a.y) == 0; + } +}; +inline double dot(V a, V b) { + return a.x * b.x + a.y * b.y; +} +inline double len(V a) { + return sqrt(dot(a, a)); +} +inline double dis(P a, P b) { + return len(b - a); +} +inline double ang(V a, V b) { + return acos(dot(a, b) / len(a) / len(b)); +} +inline double cross(V a, V b) { + return a.x * b.y - a.y * b.x; +} +inline double area(P a, P b, P c) { + return cross(b - a, c - a); +} +V rot(V a, double p) { + return V(a.x * cos(p) - a.y * sin(p), a.x * sin(p) + a.y * cos(p)); +} +V normal(V a) { + double L = len(a); + return V(-a.y / L, a.x / L); +} +P inter(P p, V v, P q, V w) { + V u = p - q; + double t = cross(w, u) / cross(v, w); + return p + v * t; +} +double dis(P p, P a, P b) { + V v1 = b - a, v2 = p - a; + return fabs(cross(v1, v2)) / len(v1); +} +double dis2(P p, P a, P b) { + if (a == b) return len(p - a); + V v1 = b - a, v2 = p - a, v3 = p - b; + if (dcmp(dot(v1, v2)) < 0) return len(v2); + else if (dcmp(dot(v1, v3)) > 0) return len(v3); + else return fabs(cross(v1, v2)) / len(v1); +} +P proj(P p, P a, P b) { + V v = b - a; + return a + v * (dot(v, p - a) / dot(v, v)); +} +bool isInter(P a1, P a2, P b1, P b2) { + double c1 = cross(a2 - a1, b1 - a1), c2 = cross(a2 - a1, b2 - a1), + c3 = cross(b2 - b1, a1 - b1), c4 = cross(b2 - b1, a2 - b1); + return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0; +} +bool onSeg(P p, P a1, P a2) { + return dcmp(cross(a1 - p, a2 - p)) == 0 && dcmp(dot(a1 - p, a2 - p)) < 0; +} +double area(P* p, int n) { + double s = 0; + p[n] = p[0]; + for (int i = 1; i < n; i ++) + s += cross(p[i] - p[0], p[i + 1] - p[0]); + return s / 2; +} +int graham(P* p, int n, P* ch) { + sort(p, p + n); + int m = 0; + for (int i = 0; i < n; i ++) { + while (m > 1 && cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m --; + ch[m ++] = p[i]; + } + int k = m; + for (int i = n - 2; i >= 0; i --) { + while (m > k && cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m --; + ch[m ++] = p[i]; + } + if (n > 1) m --; + return m; +} +struct L { + P p; + V v; + double ang; + L() {} + L(P _p, V _v) : p(_p), v(_v) { ang = atan2(v.y, v.y); } + bool operator < (const L& L) const { + return ang < L.ang; + } +}; +inline int get(P a) { + if( a.x > 0 && a.y >= 0) return 1; + if( a.x <= 0 && a.y > 0) return 2; + if( a.x < 0 && a.y <= 0) return 3; + if( a.x >= 0 && a.y < 0) return 4; + return 0; +} +inline bool cmp2 (L a, L b) { + return get(a.v) < get(b.v) || (get(a.v) == get(b.v) && dcmp( cross(a.v, b.v) ) >0); +} +bool onLeft(L l, P p) { + return cross(l.v, p - l.p) > 0; +} +P inter(L a, L b) { + return inter(a.p, a.v, b.p, b.v); +} +int half(L* l, int n, P* po) { + sort(l, l + n, cmp2); + int h, t; + P *p = new P[n]; + L *q = new L[n]; + q[h = t = 0] = l[0]; + for (int i = 1; i < n; i ++) { + while (h < t && !onLeft(l[i], p[t - 1])) t --; + while (h < t && !onLeft(l[i], p[h])) h ++; + q[++ t] = l[i]; + if (dcmp(cross(q[t].v, q[t - 1].v)) == 0) { + t --; + if (onLeft(q[t], l[i].p)) q[t] = l[i]; + } + if (h < t) p[t - 1] = inter(q[t - 1], q[t]); + } + while (h < t && !onLeft(q[h], p[t - 1])) t --; + if (t - h <= 1) return 0; + p[t] = inter(q[t], q[h]); + int m = 0; + for (int i = h; i <= t; i ++) po[m ++] = p[i]; + return m; +} +inline bool cmp (V a, V b) { + return get(a) < get(b) || (get(a) == get(b) && dcmp( cross(a, b) ) >0); +} +const int N = 101000; +int n; +P a[N], b[N], res[N]; +L l[N]; +int main() { + int T; + scanf("%d", &T); + for (int cas = 1; cas <= T; cas ++) { + scanf("%d", &n); + for (int i = 0; i < n; i ++) + a[i].scan(); + int bound = n / 3 - 1, l_c = 0; + for (int i = 0; i < n; i ++) { + int cnt = 0; + for (int j = 0; j < n; j ++) + if (j != i) + b[cnt ++] = a[j] - a[i]; + sort(b, b + cnt, cmp); + int t = 0, sum = 0; + for (int j = 0; j < cnt; j ++) { + while ((dcmp(cross(b[j], b[(t + 1) % cnt])) == 1) || + (dcmp(cross(b[j], b[(t + 1) % cnt])) == 0 && + dcmp(dot(b[j], b[(t + 1) % cnt])) == -1)) t = (t + 1) % cnt, sum ++; + if (cnt - (sum + 1) == bound) l[l_c ++] = L(a[i], b[j]); + if (t == j) t ++; + else { + while (dcmp(cross(b[j], b[(j + 1) % cnt])) == 0) j ++, sum --; + sum --; + } + } + } + int ans = half(l, l_c, res); + printf("Case #%d: %.6lf\n", cas, area(res, ans)); + } + return 0; +} diff --git a/HDOJ/5244_autoAC.cpp b/HDOJ/5244_autoAC.cpp new file mode 100644 index 0000000..77a0b9f --- /dev/null +++ b/HDOJ/5244_autoAC.cpp @@ -0,0 +1,92 @@ +#include +using namespace std; +const int MAXK = 20; +const int MAXN = (1 << MAXK); +typedef long long ll; +typedef unsigned long ul; +struct BI{ + ul d[4]; + BI(const ll& a = 0){ + d[0] = a & 0xffffffff; + d[1] = a >> 32; + d[2] = a >> 64; + d[3] = d[2]; + } + BI operator+(const BI& B)const{ + BI ret(*this); + int flg = 0; + ll tmp; + for(int i = 0; i < 4; i ++){ + tmp = ll(ret.d[i]) + ll(B.d[i]) + ll(flg); + ret.d[i] = tmp & 0xffffffff; + flg = (tmp >> 32) & 1; + } + return ret; + } + BI operator-()const{ + BI ret(*this); + int flg = 1; + ll tmp; + for(int i = 0; i < 4; i ++){ + tmp = ll(~ret.d[i]) + ll(flg); + ret.d[i] = tmp & 0xffffffff; + flg = (tmp >> 32) & 1; + } + return ret; + } + inline BI operator-(const BI& rhs)const{ + return (*this) + (- rhs); + } + void operator>>=(int k){ + int i; + for(i = 0; i < 3; i ++) + d[i] = (d[i] >> k) | (d[i+1] << (32 - k)); + d[3] = d[3] >> k; + }; + ll val(){ + return (ll(d[1]) << 32) + ll(d[0]); + } +}; +ll B[MAXN]; +BI A[MAXN]; +int N, K; +void CalcA(){ + int i, j, b; + for(j = 0; j < N; j ++) + A[j] = B[j]; + for(i = 1; i <= K; i ++){ + for(b = 0; b < N; b += (1 << i)){ + int step = (1 << (i - 1)); + for(j = b; j < b + step; j ++){ + BI t1, t2; + t1 = A[j + step] + A[j]; + t2 = A[j + step] - A[j]; + A[j] = t1; + A[j + step] = t2; + } + } + } + if(K > 0){ + for(j = 0; j < N; j ++){ + A[j] >>= (K - 1); + } + A[0] = A[0] - B[N - 1]; + } +} +int main(){ + int i, j, T; + scanf("%d", &T); + for(i = 1; i <= T; i ++){ + scanf("%d", &K); + N = 1 << K; + for(j = 0; j < N; j ++){ + scanf("%I64d", &B[j]); + } + CalcA(); + printf("Case #%d:", i); + for(j = 0; j < N; j ++) + printf(" %I64d", A[j].val()); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/5245_autoAC.cpp b/HDOJ/5245_autoAC.cpp new file mode 100644 index 0000000..fcf6b72 --- /dev/null +++ b/HDOJ/5245_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +using namespace std; +int main() +{ + int t,tm,k; + double n,m; + scanf("%d",&t);tm=t; + while(t--) + { + scanf("%lf%lf%d",&n,&m,&k); + double ans=0; + for(double i=1;i<=n;i++) + for(double j=1;j<=m;j++) + { + double p=m*n; + p+=(i-1)*(j-1)*(n-i+1)*(m-j+1); + p+=(i-1)*(m-j)*(n-i+1)*j; + p+=(j-1)*(n-i)*(m-j+1)*i; + p+=(n-i)*(m-j)*i*j; + p+=(i-1)*m*(n-i+1); + p+=(m-j)*n*j; + p+=(n-i)*m*i; + p+=(j-1)*n*(m-j+1); + p=p/n/n/m/m; + ans+=1-(pow(1-p,k)); + } + printf("Case #%d: %d\n",tm-t,int(ans+0.5)); + } + return 0; +} diff --git a/HDOJ/5246_autoAC.cpp b/HDOJ/5246_autoAC.cpp new file mode 100644 index 0000000..3d3d1e0 --- /dev/null +++ b/HDOJ/5246_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +using namespace std; +const int N = 10005; +long long n, m, k; +long long s[N]; +int main() { + int t, cas = 1; + scanf("%d", &t); + while (t--) { + scanf("%lld%lld%lld", &n, &m, &k); + for (int i = 0; i < n; i++) + scanf("%lld", &s[i]); + sort(s, s + n); + if (s[0] > m) { + printf("Case #%d:\nmadan!\n", cas++); + continue; + } + if (s[n - 1] <= m) { + printf("Case #%d:\nwhy am I so diao?\n", cas++); + continue; + } + for (int i = 0; i < n; i++) { + if (s[i] > m) { + int flag = 1, flag2 = 0; + m = s[i - 1]; + for (int j = i; j < n; j++) { + if (m + k >= s[j]) + continue; + else { + m = s[j - 1]; + if (k > 0) + k--; + if (m + k < s[j]) { + flag = 0; + break; + } + j--; + } + } + if (!flag) + printf("Case #%d:\nmadan!\n", cas++); + else + printf("Case #%d:\nwhy am I so diao?\n", cas++); + break; + } + } + } + return 0; +} diff --git a/HDOJ/5247_autoAC.cpp b/HDOJ/5247_autoAC.cpp new file mode 100644 index 0000000..e81214c --- /dev/null +++ b/HDOJ/5247_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +using namespace std; +typedef long long LL; +const int maxn = 10005; +sets; +set::iterator it1,it2; +int n,m; +int num[maxn] = {0}; +LL arr[maxn]; +int main(){ + scanf("%d%d",&n,&m); + for(int i = 0; i < n; i++) + scanf("%I64d",&arr[i]); + for(int i = 0; i < n; i++){ + s.clear(); + s.insert(arr[i]); + num[1] ++; + for(int j = i + 1; j < n; j++){ + if(!s.count(arr[j])) + s.insert(arr[j]); + else + break; + it1 = s.begin(); + it2 = s.end(); + it2 --; + LL e1 = *it1,e2 = *it2; + if(e2 - e1 == s.size() - 1){ + num[s.size()] ++; + } + } + } + printf("Case #1:\n"); + while(m--){ + int k; + scanf("%d",&k); + printf("%d\n",num[k]); + } + return 0; +} diff --git a/HDOJ/5248_autoAC.cpp b/HDOJ/5248_autoAC.cpp new file mode 100644 index 0000000..9839965 --- /dev/null +++ b/HDOJ/5248_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define MOD 1000000007 +const int INF=0x3f3f3f3f; +const double eps=1e-5; +typedef long long ll; +#define cl(a) memset(a,0,sizeof(a)) +#define ts printf("*****\n"); +const int MAXN=100005; +int n,m,tt; +int a[MAXN],b[MAXN]; +bool check(int mid) +{ + for(int i=1;i<=n;i++) + { + b[i]=a[i]; + } + for(int i=1;i<=n;i++) + { + if(i==1) + { + b[i]-=mid; + continue; + } + if(b[i]<=b[i-1]) + { + if((b[i-1]+1)-b[i]<=mid) + b[i]=b[i-1]+1; + else + { + return 0; + } + } + if(b[i]-mid>b[i-1]) + { + b[i]=b[i]-mid; + } + else + { + b[i]=b[i-1]+1; + } + } + return 1; +} +int main() +{ + int i,j,k; + int ca=1; + scanf("%d",&tt); + while(tt--) + { + printf("Case #%d:\n",ca++); + scanf("%d",&n); + for(i=1;i<=n;i++) scanf("%d",a+i); + int l=0; + int r=1000005; + int ans=0; + while(l<=r) + { + int mid=(l+r)>>1; + if(check(mid)) + { + ans=mid; + r=mid-1; + } + else + l=mid+1; + } + printf("%d\n",ans); + } +} diff --git a/HDOJ/5249_autoAC.cpp b/HDOJ/5249_autoAC.cpp new file mode 100644 index 0000000..2090b14 --- /dev/null +++ b/HDOJ/5249_autoAC.cpp @@ -0,0 +1,54 @@ +#include +#include +#include +#include +#include +using namespace std; +set A, B; +queue q; +int n, cas = 1; +int main() { + while (scanf("%d", &n) == 1) { + printf("Case #%d:\n", cas++); + while (!q.empty()) + q.pop(); + A.clear(); + B.clear(); + char str[10]; + int m = 0, d; + while (n--) { + scanf("%s", str); + if (str[0] == 'i') { + scanf("%d", &d); + q.push(d); + if (A.size() == 0 || d <= *A.rbegin()) + A.insert(d); + else + B.insert(d); + m++; + } + else if (str[0] == 'o') { + int temp = q.front(); + q.pop(); + if (A.find(temp) == A.end()) + B.erase(temp); + else + A.erase(temp); + m--; + } + else + printf("%d\n", *A.rbegin()); + while (m > 0 && A.size() < m / 2 + 1) { + int temp = *B.begin(); + A.insert(temp); + B.erase(temp); + } + while (m > 0 && A.size() > m / 2 + 1) { + int temp = *A.rbegin(); + B.insert(temp); + A.erase(temp); + } + } + } + return 0; +} diff --git a/HDOJ/5251_autoAC.cpp b/HDOJ/5251_autoAC.cpp new file mode 100644 index 0000000..87fea91 --- /dev/null +++ b/HDOJ/5251_autoAC.cpp @@ -0,0 +1,173 @@ +#pragma comment(linker, "/STACK:1024000000,1024000000") +#include +#include +#include +#include +using namespace std; +typedef double typev; +const double eps = 1e-8; +const int N = 50005; +int sign(double d){ + return d < -eps ? -1 : (d > eps); +} +struct point{ + typev x, y; + point operator-(point d){ + point dd; + dd.x = this->x - d.x; + dd.y = this->y - d.y; + return dd; + } + point operator+(point d){ + point dd; + dd.x = this->x + d.x; + dd.y = this->y + d.y; + return dd; + } +}ps[N]; +//int n, cn; +double dist(point d1, point d2){ + return sqrt(pow(d1.x - d2.x, 2.0) + pow(d1.y - d2.y, 2.0)); +} +double dist2(point d1, point d2){ + return pow(d1.x - d2.x, 2.0) + pow(d1.y - d2.y, 2.0); +} +bool cmp(point d1, point d2){ + return d1.y < d2.y || (d1.y == d2.y && d1.x < d2.x); +} +typev xmul(point st1, point ed1, point st2, point ed2){ + return (ed1.x - st1.x) * (ed2.y - st2.y) - (ed1.y - st1.y) * (ed2.x - st2.x); +} +typev dmul(point st1, point ed1, point st2, point ed2){ + return (ed1.x - st1.x) * (ed2.x - st2.x) + (ed1.y - st1.y) * (ed2.y - st2.y); +} +struct poly{ + static const int N = 50005; + point ps[N+5]; + int pn; + poly() { pn = 0; } + void push(point tp){ + ps[pn++] = tp; + } + int trim(int k){ + return (k+pn)%pn; + } + void clear(){ pn = 0; } +}; +poly graham(point* ps, int n){ + sort(ps, ps + n, cmp); + poly ans; + if(n <= 2){ + for(int i = 0; i < n; i++){ + ans.push(ps[i]); + } + return ans; + } + ans.push(ps[0]); + ans.push(ps[1]); + point* tps = ans.ps; + int top = -1; + tps[++top] = ps[0]; + tps[++top] = ps[1]; + for(int i = 2; i < n; i++){ + while(top > 0 && xmul(tps[top - 1], tps[top], tps[top - 1], ps[i]) <= 0) top--; + tps[++top] = ps[i]; + } + int tmp = top; + for(int i = n - 2; i >= 0; i--){ + while(top > tmp && xmul(tps[top - 1], tps[top], tps[top - 1], ps[i]) <= 0) top--; + tps[++top] = ps[i]; + } + ans.pn = top; + return ans; +} +point getRoot(point p, point st, point ed){ + point ans; + double u=((ed.x-st.x)*(ed.x-st.x)+(ed.y-st.y)*(ed.y-st.y)); + u = ((ed.x-st.x)*(ed.x-p.x)+(ed.y-st.y)*(ed.y-p.y))/u; + ans.x = u*st.x+(1-u)*ed.x; + ans.y = u*st.y+(1-u)*ed.y; + return ans; +} +point change(point st, point ed, point next, double l){ + point dd; + dd.x = -(ed - st).y; + dd.y = (ed - st).x; + double len = sqrt(dd.x * dd.x + dd.y * dd.y); + dd.x /= len, dd.y /= len; + dd.x *= l, dd.y *= l; + dd = dd + next; + return dd; +} +double getMinAreaRect(point* ps, int n, point* ds){ + int cn, i; + double ans; + point* con; + poly tpoly = graham(ps, n); + con = tpoly.ps; + cn = tpoly.pn; + if(cn <= 2){ + ds[0] = con[0]; ds[1] = con[1]; + ds[2] = con[1]; ds[3] = con[0]; + ans=0; + }else{ + int l, r, u; + double tmp, len; + con[cn] = con[0]; + ans = 1e40; + l = i = 0; + while(dmul(con[i], con[i+1], con[i], con[l]) + >= dmul(con[i], con[i+1], con[i], con[(l-1+cn)%cn])){ + l = (l-1+cn)%cn; + } + for(r=u=i = 0; i < cn; i++){ + while(xmul(con[i], con[i+1], con[i], con[u]) + <= xmul(con[i], con[i+1], con[i], con[(u+1)%cn])){ + u = (u+1)%cn; + } + while(dmul(con[i], con[i+1], con[i], con[r]) + <= dmul(con[i], con[i+1], con[i], con[(r+1)%cn])){ + r = (r+1)%cn; + } + while(dmul(con[i], con[i+1], con[i], con[l]) + >= dmul(con[i], con[i+1], con[i], con[(l+1)%cn])){ + l = (l+1)%cn; + } + tmp = dmul(con[i], con[i+1], con[i], con[r]) - dmul(con[i], con[i+1], con[i], con[l]); + tmp *= xmul(con[i], con[i+1], con[i], con[u]); + tmp /= dist2(con[i], con[i+1]); + len = xmul(con[i], con[i+1], con[i], con[u])/dist(con[i], con[i+1]); + if(sign(tmp - ans) < 0){ + ans = tmp; + ds[0] = getRoot(con[l], con[i], con[i+1]); + ds[1] = getRoot(con[r], con[i+1], con[i]); + ds[2] = change(con[i], con[i+1], ds[1], len); + ds[3] = change(con[i], con[i+1], ds[0], len); + } + } + } + return ans+eps; +} +int main () +{ + int t ,n ,i ,NN ,cas = 1; + point ds[10]; + scanf("%d" ,&t); + while(t--) + { + scanf("%d" ,&NN); + int n = 0; + for(i = 1 ;i <= NN ;i ++) + { + for(int j = 1 ;j <= 4 ;j ++) + { + scanf("%lf %lf" ,&ps[n].x ,&ps[n].y); + n++; + } + } + double ans = getMinAreaRect(ps ,n ,ds); + printf("Case #%d:\n" ,cas ++); + printf("%.0lf\n" ,ans); + } + return 0; +} diff --git a/HDOJ/5253_autoAC.cpp b/HDOJ/5253_autoAC.cpp new file mode 100644 index 0000000..9f6f070 --- /dev/null +++ b/HDOJ/5253_autoAC.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +using namespace std; +#define N 1005 +int father[N*N]; +struct EDGE +{ + int u,v; + int len; + bool operator<(const EDGE& a)const + { + return len0) + { + e.u=i*n+j; + e.v=i*n+j-1; + e.len=abs(map[i][j]-map[i][j-1]); + edge[k++]=e; + } + if(i>0) + { + e.u=i*n+j; + e.v=i*n+j-n; + e.len=abs(map[i][j]-map[i-1][j]); + edge[k++]=e; + } + } + sort(edge,edge+k); + printf ("Case #%d:\n", ++t); + printf ("%d\n", process()); + } + return 0; +} diff --git a/HDOJ/5254_autoAC.cpp b/HDOJ/5254_autoAC.cpp new file mode 100644 index 0000000..bcee967 --- /dev/null +++ b/HDOJ/5254_autoAC.cpp @@ -0,0 +1,2 @@ +10 +&#8232;01&#8232; diff --git a/HDOJ/5255_autoAC.cpp b/HDOJ/5255_autoAC.cpp new file mode 100644 index 0000000..2cd67b5 --- /dev/null +++ b/HDOJ/5255_autoAC.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +#include +#include +#include +#include +#define N 2000010 +#define M 1000 +using namespace std; +double n; +long long a,b,z,pp,qq,ans[N],P,p,q,o,k,tot,i,j,l; +long long gcd(long long a,long long b) +{ + if (b==0) return a; + return gcd(b,a%b); +} +int check(long long p,long long q) +{ + if (p==0) return 0; + if (p>=P) return 0; + long long a,b,c=1,pp; + a=p%10; + pp=p; + while (pp) + { + b=pp%10; + pp=pp/10; + c=c*10; + } + c=c/10; + p=p-a+b-b*c+a*c; + if (p==q) return 1;return 0; +} +int main() +{ + int test,ii; + P=1000000; + P=P*10000; + scanf("%d",&test); + for (ii=1;ii<=test;ii++) + { + tot=0; + scanf("%lf",&n); + p=(n+0.0000005)*1000000; + q=p/gcd(p,1000000); + p=1000000/gcd(p,1000000); + o=abs(p-q); + b=10;a=0; + for (k=0;k<=8;k++) + { + for (i=0;i<=9;i++) + for (j=0;j<=9;j++) + { + z=b*i+a*10+j; + if (z%o==0) + { + z=z/o; + pp=p*z;qq=q*z; + if (check(pp,qq)) + { + tot++; + ans[tot]=pp; + } + } + } + a=a*10+9; + b=b*10; + } + sort(ans+1,ans+1+tot); + j=0;ans[0]=-1; + for (i=1;i<=tot;i++) + if (ans[i]!=ans[i-1]) + { + j++;ans[j]=ans[i]; + } + tot=j; + printf("Case #%d:\n",ii); + printf("%I64d\n",tot); + for (i=1;i<=tot-1;i++) + printf("%I64d ",ans[i]); + if (tot) + printf("%I64d\n",ans[tot]); + } +} diff --git a/HDOJ/5256_autoAC.cpp b/HDOJ/5256_autoAC.cpp new file mode 100644 index 0000000..e380903 --- /dev/null +++ b/HDOJ/5256_autoAC.cpp @@ -0,0 +1,29 @@ +#include +#include +using namespace std; +const int N = 100005; +int n, s[N], f[N]; +int main() { + int t, cas = 1; + scanf("%d", &t); + while (t--) { + scanf("%d", &n); + int a; + for (int i = 0; i < n; i++) { + scanf("%d", &a); + s[i] = a - i; + } + int k = 0; + f[k++] = s[0]; + for (int i = 1; i < n; i++) { + if (s[i] >= f[k - 1]) + f[k++] = s[i]; + else { + int pos = upper_bound(f, f + k, s[i]) - f; + f[pos] = s[i]; + } + } + printf("Case #%d:\n%d\n", cas++, n - k); + } + return 0; +} diff --git a/HDOJ/5258_autoAC.cpp b/HDOJ/5258_autoAC.cpp new file mode 100644 index 0000000..1f27916 --- /dev/null +++ b/HDOJ/5258_autoAC.cpp @@ -0,0 +1,122 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 2000001 +#define mod 10007 +#define eps 1e-9 +int Num; +char CH[20]; +const int inf=0x3f3f3f3f; +const ll infll = 0x3f3f3f3f3f3f3f3fLL; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +inline void P(int x) +{ + Num=0;if(!x){putchar('0');puts("");return;} + while(x>0)CH[++Num]=x%10,x/=10; + while(Num)putchar(CH[Num--]+48); + puts(""); +} +int g[50][50]; +map H1; +map H2; +vector x; +vector y; +vector kiss[50]; +struct node +{ + int x1,x2,y1,y2; +}a[100]; +int main() +{ + int t=read(); + for(int cas=1;cas<=t;cas++) + { + memset(g,0,sizeof(g)); + memset(a,0,sizeof(a)); + H1.clear(); + H2.clear(); + x.clear(); + y.clear(); + for(int i=0;i<50;i++) + kiss[i].clear(); + int n=read(); + for(int i=0;ia[i].x2) + swap(a[i].x1,a[i].x2); + if(a[i].y1>a[i].y2) + swap(a[i].y1,a[i].y2); + x.push_back(a[i].x1); + x.push_back(a[i].x2); + y.push_back(a[i].y1); + y.push_back(a[i].y2); + } + sort(x.begin(),x.end()); + sort(y.begin(),y.end()); + x.erase(unique(x.begin(),x.end()),x.end()); + y.erase(unique(y.begin(),y.end()),y.end()); + for(int i=0;i +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int MOD = 1e9 + 7; +const int INF = 10000000; +const int N = 5000 + 10; +struct State { + int a[4], b[4]; + void read() { + for(int i = 0; i < 4; i++) { + scanf("%d%d", &a[i], &b[i]); + } + } +} s[N]; +int seq[30][4], dp[N][30]; +bool check(int b[], int q[]) { + for(int i = 1; i < 4; i++) { + if(b[q[i]] < b[q[i - 1]]) return false; + } + return true; +} +int calc(State& A, State& B, int q0[], int q1[]) { + int dis = 0; + for(int i = 0; i < 4; i++) { + dis += abs(A.a[q0[i]] - B.a[q1[i]]); + dis += abs(A.b[q0[i]] - B.b[q1[i]]); + } + return dis; +} +int main() { + int T, C = 1, n; + int A[4] = {0, 1, 2, 3}; + int nq = 0; + do { + for(int i = 0; i < 4; i++) seq[nq][i] = A[i]; + nq ++; + } while(next_permutation(A, A + 4)); + scanf("%d", &T); + while(T--) { + printf("Case #%d:\n", C++); + scanf("%d" , &n); + for(int i = 1; i <= n; i++) { + s[i].read(); + } + for(int i = 0; i < 4; i++) + s[0].b[i] = i + 1, s[0].a[i] = 0; + for(int i = 0; i < 24; i++) { + if(check(s[1].b, seq[i])) { + dp[1][i] = calc(s[0], s[1], seq[0], seq[i]); + } else { + dp[1][i] = INF; + } + } + for(int i = 2; i <= n; i++) { + for(int j = 0; j < 24; j++) { + dp[i][j] = INF; + if(!check(s[i].b, seq[j])) continue; + for(int k = 0; k < 24; k++) { + if(dp[i - 1][k] == INF) continue; + dp[i][j] = min(dp[i][j], dp[i - 1][k] + calc(s[i - 1], s[i], seq[k], seq[j])); + } + } + } + int ans = INF; + for(int i = 0; i < 24; i++) { + ans = min(ans, dp[n][i]); + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/5260_autoAC.cpp b/HDOJ/5260_autoAC.cpp new file mode 100644 index 0000000..06e998d --- /dev/null +++ b/HDOJ/5260_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair Pii; +typedef pair Pll; +#define foreach(it,s) for(__typeof(s.begin()) it=s.begin();it!=s.end();it++) +const int maxn = 50 + 5; +const int maxe = 500 + 5; +int n, m, s, t; +struct Tedge { + int u, v; + string w; + Tedge(int u = 0, int v = 0, string w = ""):u(u), v(v), w(w){}; +}; +vector edge[maxn]; +string dis[maxn]; +bool vis[maxn]; +string bf() +{ + int clk = 0; + memset(vis, false, sizeof(vis)); + dis[t] = ""; vis[t] = true; + while (1) { + bool update = false; + for (int ii=0;iiv]) { + int u = i->u, v = i->v; + string tmp = i->w + dis[v]; + if (!vis[u] || tmp < dis[u]) { + dis[u] = tmp; + update = vis[u] = true; + if (clk >= n - 1 && u == s) return "Tough way!"; + } + } + } + if (!update || ++clk > n * 6) break; + } + return vis[s] ? dis[s]: "Tough way!"; +} +int main() +{ + int cas = 0; + int T; + scanf("%d", &T); + while (T--) { + scanf("%d%d%d%d", &n, &m, &s, &t); + for (int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int maxn=200010; +int N; +int maxvid,maxvsum; +LL R; +int height[maxn]; +struct IntervalTree +{ + LL sum[maxn<<2]; + int id[maxn<<2]; + void build(int o,int l,int r) + { + if(l==r) + { + sum[o]=R*(l-1)+height[l]; + id[o]=l; + return ; + } + int mid=(l+r)>>1; + build(o<<1,l,mid); + build(o<<1|1,mid+1,r); + pushup(o); + } + void pushup(int o) + { + if(sum[o<<1]maxvsum) + { + maxvsum=sum[o]; + maxvid=id[o]; + } + return ; + } + int mid=(l+r)>>1; + if(q1<=mid)query(o<<1,l,mid,q1,q2); + if(q2>mid)query(o<<1|1,mid+1,r,q1,q2); + } +}tree; +int main() +{ + int T,cas=1; + scanf("%d",&T); + while(T--) + { + scanf("%d%I64d",&N,&R); + for(int i=1;i<=N;i++) + scanf("%d",&height[i]); + for(int i=1;i<=N;i++) + height[i+N]=height[i]; + tree.build(1,1,N*2); + LL anssum=0; + int x,y,p; + pair ans=make_pair(N,N),tmp; + for(int i=1;i<=N*2;i++) + { + int r=i+N/2,l=i-N/2; + if(r>N*2||l<1)continue; + maxvid=maxvsum=0; + tree.query(1,1,N*2,i+1,r); + x=maxvid; + maxvid=maxvsum=0; + tree.query(1,1,N*2,l,i-1); + y=maxvid; + if((i-y)*R+height[i]+height[y]>anssum) + { + anssum=(i-y)*R+height[i]+height[y]; + if(y>N)y-=N; + p=i; + if(p>N)p-=N; + tmp=make_pair(min(y,p),max(y,p)); + ans=tmp; + } + else if((i-y)*R+height[i]+height[y]==anssum) + { + if(y>N)y-=N; + p=i; + if(p>N)p-=N; + tmp=make_pair(min(y,p),max(y,p)); + if(tmpanssum) + { + anssum=(x-i)*R+height[x]+height[i]; + if(x>N)x-=N; + p=i; + if(p>N)p-=N; + tmp=make_pair(min(x,p),max(x,p)); + ans=tmp; + } + else if((x-i)*R+height[x]+height[i]==anssum) + { + if(x>N)x-=N; + p=i; + if(p>N)p-=N; + tmp=make_pair(min(x,p),max(x,p)); + if(tmp +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +using namespace std; +typedef long long LL; +const int maxn=100010; +const int MOD=1e9+7; +char str[maxn]; +int dp[maxn]; +int pos[30]; +int nxt[maxn][30]; +LL cnt[maxn]; +int main() +{ + int T,cas=1; + scanf("%d",&T); + while(T--) + { + scanf("%s",str); + int N=strlen(str); + for(int i=0;i<26;i++)pos[i]=N+1; + for(int i=N-1;i>=0;i--) + { + pos[str[i]-'a']=i+1; + for(int j=0;j<26;j++) + nxt[i][j]=pos[j]; + } + dp[N+1]=0,dp[N]=1; + for(int i=N-1;i>=0;i--) + { + int minv=N+1; + for(int j=0;j<26;j++) + minv=min(minv,dp[nxt[i][j]]+1); + dp[i]=minv; + } + memset(cnt,0,sizeof(cnt)); + cnt[N]=26,cnt[N+1]=1; + for(int i=N-1;i>=0;i--) + { + for(int j=0;j<26;j++) + if(dp[i]==dp[nxt[i][j]]+1) + { + cnt[i]+=cnt[nxt[i][j]]; + if(cnt[i]>=MOD)cnt[i]-=MOD; + } + } + printf("Case #%d:\n%d %I64d\n",cas++,dp[0],cnt[0]); + } + return 0; +} diff --git a/HDOJ/5264_autoAC.cpp b/HDOJ/5264_autoAC.cpp new file mode 100644 index 0000000..f1b9858 --- /dev/null +++ b/HDOJ/5264_autoAC.cpp @@ -0,0 +1,28 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 1005; +int T, n, m; +string a, b, s; +int main() +{ + scanf("%d", &T); + while (T--) + { + cin >> s; + b = a = ""; + for (int i = 0; s[i]; i++) + { + if (i & 1) b = s[i] + b; + else a = a + s[i]; + } + cout << a << endl; + cout << b << endl; + } +} diff --git a/HDOJ/5265_autoAC.cpp b/HDOJ/5265_autoAC.cpp new file mode 100644 index 0000000..9ea92bf --- /dev/null +++ b/HDOJ/5265_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +using namespace std; +const int maxn=100000+5; +int data[maxn]; +int main() +{ + int m,p; + while(scanf("%d%d",&m,&p)!=-1) + { + for(int i=0; idata[m-2]) + printf("%d\n",data[m-1]+data[m-2]); + else + { + int now=0; + int ans=data[m-1]+data[m-2]-p; + for(int i=m-1; i>=1; i--) + { + for(int j=now; jdata[j]) + ans=max(data[i]+data[j],ans); + else + { + if(j>0) + now=j-1; + break; + } + if(ans==p-1) + break; + } + if(ans==p-1) + break; + } + printf("%d\n",ans); + } + } + return 0; +} diff --git a/HDOJ/5268_autoAC.cpp b/HDOJ/5268_autoAC.cpp new file mode 100644 index 0000000..38da8f9 --- /dev/null +++ b/HDOJ/5268_autoAC.cpp @@ -0,0 +1,20 @@ +#include +#include +using namespace std; +int main() +{ + int T,a,b; + cin>>T; + for(int k=1; k<=T; k++) + { + int sum,ans=0; + for(int i=2; i<=5; i++) + { + cin>>a>>b; + sum=2*i*(250-a)-50*b; + ans+=max(sum,(int)(0.4*i*500)); + } + cout<<"Case #"< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define zeros(a) memset(a,0,sizeof(a)) +#define ones(a) memset(a,-1,sizeof(a)) +#define sc(a) scanf("%d",&a) +#define sc2(a,b) scanf("%d%d",&a,&b) +#define rep(i,n) for(int i=0;i +#include +#include +#include +#define cl(a,b) memset(a,b,sizeof(a)) +#define ll long long +#define ull unsigned long long +using namespace std; +#define maxn 200005 +ull aa[maxn],bb[maxn]; +ull taa[maxn],tbb[maxn]; +ull cc[64],be[64],en[64]; +int n; +void initcc() +{ + cl(cc,0); + cc[0]=1; + be[0]=1; + en[0]=2; + for(int i=1;i<=62;i++) + { + cc[i]=cc[i-1]*2+1; + be[i]=be[i-1]*2; + en[i]=en[i-1]*2; + } +} +int main() +{ + initcc(); + int tt,ii; + cin>>tt; + ii=0; + while(tt--) + { + scanf("%d",&n); + int i,j,k; + for(i=0;i=0&&tbb[s1]+taa[i]>=be[k])s1--; + while(e1>=0&&tbb[e1]+taa[i]>=en[k])e1--; + while(s2>=0&&tbb[s2]+taa[i]>=be[k]+en[k])s2--; + while(e2>=0&&tbb[e2]+taa[i]>=en[k+1])e2--; + bitc+=e1-s1; + bitc+=e2-s2; + } + res+=be[k]*(bitc%2); + } + printf("Case #%d: %llu\n",++ii,res); + } + return 0; +} diff --git a/HDOJ/5272_autoAC.cpp b/HDOJ/5272_autoAC.cpp new file mode 100644 index 0000000..d155621 --- /dev/null +++ b/HDOJ/5272_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 2000001 +#define mod 10007 +#define eps 1e-5 +const int inf=0x3f3f3f3f; +const ll infll = 0x3f3f3f3f3f3f3f3fLL; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +int main() +{ + int t=read(); + while(t--){ + ll n=read(); + int ans=0; + int flag=1; + while(n) + { + if(flag) + { + if(n&1) + { + ans++; + flag=0; + } + } + else if(!(n&1)) + { + flag=1; + } + n>>=1; + } + cout< +#include +#include +#include +using namespace std; +const int N = 1005; +#define LL __int64 +int n,q,a[N],l,r,dp[N][N]; +int main() +{ + while(scanf("%d%d",&n,&q)>0){ + for(int i=1; i<=n; i++) + scanf("%d",&a[i]); + memset(dp,0,sizeof(dp)); + for(int k=1; ka[j]) + dp[i][j]++; + } + while(q--){ + scanf("%d%d",&l,&r); + printf("%d\n",dp[l][r]); + } + } + return 0; +} diff --git a/HDOJ/5274_autoAC.cpp b/HDOJ/5274_autoAC.cpp new file mode 100644 index 0000000..7fdd98f --- /dev/null +++ b/HDOJ/5274_autoAC.cpp @@ -0,0 +1,130 @@ +#pragma comment(linker,"/STACK:1024000000,1024000000") +#include +#include +#include +#include +using namespace std; +const int N = 100005; +#define LL __int64 +struct EDG{ + int to,next; +}edg[N*2]; +int eid,head[N]; +int fath[N],deep[N],top[N],num[N],son[N],p[N],pos; +void init(){ + pos=0; eid=0; + memset(head,-1,sizeof(head)); +} +void addEdg(int u,int v){ + edg[eid].to=v; edg[eid].next=head[u]; head[u]=eid++; + edg[eid].to=u; edg[eid].next=head[v]; head[v]=eid++; +} +void dfs(int u,int pre,int d){ + fath[u]=pre; num[u]=1; deep[u]=d; son[u]=-1; + for(int i=head[u]; i!=-1; i=edg[i].next){ + int v=edg[i].to; + if(v==pre)continue; + dfs(v,u,d+1); + num[u]+=num[v]; + if(son[u]==-1||num[son[u]]>1; + build(l,m,k<<1); + build(m+1,r,k<<1|1); + root[k]=root[k<<1]^root[k<<1|1]; +} +void updata(int l,int r,int k,int id,int vule){ + if(l==r){ + root[k]=vule; + return ; + } + int m=(l+r)>>1; + if(id<=m) + updata(l,m,k<<1,id,vule); + else + updata(m+1,r,k<<1|1,id,vule); + root[k]=root[k<<1]^root[k<<1|1]; +} +int query(int l,int r,int k,int L,int R){ + if(L<=l&&r<=R){ + return root[k]; + } + int m=(l+r)>>1 , ans=0; + if(L<=m) + ans^= query(l,m,k<<1,L,R); + if(mdeep[v]) + swp(u,v); + ans^=query(1,pos,1,p[u],p[v]); + return ans; +} +int main() +{ + int T,n,q,val[N],u,v; + scanf("%d",&T); + while(T--){ + scanf("%d%d",&n,&q); + init(); + for(int i=1; i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long Int; +const int M=1e9+7; +int rev[250002]; +int dp[3002][3002]; +int x[3002],y[3002]; +inline int getrev(int x){return x<0?-rev[-x]:rev[x];} +int main() +{ + rev[1]=1; + for(int i=2;i<=250000;i++)rev[i]=(M-M/i)*(Int)rev[M%i]%M; + int n; + while(scanf("%d",&n)!=EOF) + { + for(int i=1;i<=n;i++)scanf("%d%d",x+i,y+i); + for(int i=1;i<=n;i++)dp[0][i]=y[i]; + for(int i=1;i<=n;i++) + for(int j=1;j+i<=n;j++) + dp[i][j]=((dp[i-1][j+1]-dp[i-1][j])*(Int)getrev(x[i+j]-x[j])%M+M)%M; + int m;scanf("%d",&m); + while(m--) + { + int l,r,q;scanf("%d%d%d",&l,&r,&q); + int ans=0,cur=1; + for(int i=0;i<=r-l;i++) + { + ans+=dp[i][l]*(Int)cur%M; + if(ans>=M)ans-=M; + cur=(cur*(Int)(q-x[l+i])%M+M)%M; + }printf("%d\n",ans); + } + } +} diff --git a/HDOJ/5276_autoAC.cpp b/HDOJ/5276_autoAC.cpp new file mode 100644 index 0000000..e0b6b93 --- /dev/null +++ b/HDOJ/5276_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +using namespace std; +int main() +{ + int n; + while(scanf("%d", &n) != EOF) + { + int h=0,m=0,s=0; + for (int i = 0; i < 12 * 60 * 60; i = i + 10) + { + int time1 = (i * 1200) % 4320000; + int time2 = (i * 100) % 4320000; + int time; + if (time1 > time2) + time = time1 - time2; + else + time = time2 - time1; + if (time > 2160000) + time = 4320000 - time; + if (time == n) + { + int h = i / (60 * 60); + int m = (i - h * (60 * 60)) / 60; + int s = (i % 60) - (i % 60) % 10; + printf("%02d:%02d:%02d\n", h, m, s); + } + } + } + return 0; +} diff --git a/HDOJ/5277_autoAC.cpp b/HDOJ/5277_autoAC.cpp new file mode 100644 index 0000000..35b5eac --- /dev/null +++ b/HDOJ/5277_autoAC.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long ll; +using namespace std; +#define sspeed ios_base::sync_with_stdio(0);cin.tie(0) +#define maxn 1005 +#define mod 10007 +#define eps 1e-9 +const int inf=0x3f3f3f3f; +const ll infll = 0x3f3f3f3f3f3f3f3fLL; +inline ll read() +{ + ll x=0,f=1;char ch=getchar(); + while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();} + while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();} + return x*f; +} +struct node +{ + int x,y; +}; +node a[maxn]; +int g[maxn][maxn]; +vector G[maxn]; +int one,two,three,four; +int n,m; +void init() +{ + one=two=three=four=0; + memset(a,0,sizeof(a)); + memset(g,0,sizeof(g)); + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const ll mod=998244353; +bool a[1000][1000]; +int n,m,au[1000][9],p[1000][1000],ee,fa[900],num[900]; +ll two[1000]; +struct edge { + int x,y,next; +}e[8888888]; +void addedge(int x,int y,int u,int v) { + if(x==y) return; + if(x>y) {x=x^y;y=x^y;x=x^y;} + e[ee].x=u;e[ee].y=v;e[ee].next=p[x][y];p[x][y]=ee++; +} +void init() { + int i,j,k,x,y; + queue qx,qy;ee=0; + for(i=1;i<=n;i++) {fa[i]=i;num[i]=1;} + for(i=1;i +#include +#include +using namespace std ; +typedef long long LL ; +#define clr(a,x); memset ( a , x , sizeof a ) ; +const int MAXN = 1 << 17 ; +const int mod = 998244353 ; +const int g = 3 ; +LL f[MAXN] , invf[MAXN] ; +LL tcnt[MAXN] ; +LL dp[MAXN] , dp2[MAXN] ; +LL x1[MAXN] , x2[MAXN] , x3[MAXN] ; +int n ; +LL power ( LL a , int b ) { + LL res = 1 , tmp = a ; + while ( b ) { + if ( b & 1 ) res = res * tmp % mod ; + tmp = tmp * tmp % mod ; + b >>= 1 ; + } + return res ; +} +void NTT ( LL y[] , int n , int rev ) { + for ( int i = 1 , j , k , t ; i < n ; ++ i ) { + for ( j = 0 , k = n >> 1 , t = i ; k ; k >>= 1 , t >>= 1 ) { + j = j << 1 | ( t & 1 ) ; + } + if ( i < j ) swap ( y[i] , y[j] ) ; + } + for ( int s = 2 , ds = 1 ; s <= n ; ds = s , s <<= 1 ) { + LL wn = power ( g , ( mod - 1 ) / s ) ; + if ( !rev ) wn = power ( wn , mod - 2 ) ; + for ( int k = 0 ; k < n ; k += s ) { + LL w = 1 , t ; + for ( int i = k ; i < k + ds ; ++ i , w = w * wn % mod ) { + y[i + ds] = ( y[i] - ( t = y[i + ds] * w % mod ) + mod ) % mod ; + y[i] = ( y[i] + t ) % mod ; + } + } + } + if ( !rev ) { + LL invn = power ( n , mod - 2 ) ; + for ( int i = 0 ; i < n ; ++ i ) { + y[i] = y[i] * invn % mod ; + } + } +} +void cdq_fz ( int l , int r ) { + if ( l == r ) return ; + if ( l + 1 == r ) { + dp[r] = ( dp[r] + dp[l] ) % mod ; + return ; + } + int m = ( l + r ) >> 1 , n1 = 1 ; + cdq_fz ( l , m ) ; + while ( n1 <= r - l + 1 ) n1 <<= 1 ; + for ( int i = 0 ; i < n1 ; ++ i ) { + x1[i] = l + i <= m ? dp[l + i] * invf[l + i] % mod : 0 ; + x2[i] = l + i <= r ? tcnt[i + 1] * invf[i] % mod : 0 ; + x3[i] = l + i <= r ? tcnt[i + 2] * invf[i] % mod : 0 ; + } + NTT ( x1 , n1 , 1 ) ; + NTT ( x2 , n1 , 1 ) ; + NTT ( x3 , n1 , 1 ) ; + for ( int i = 0 ; i < n1 ; ++ i ) { + x3[i] = x1[i] * x3[i] % mod ; + x2[i] = x1[i] * x2[i] % mod ; + } + NTT ( x2 , n1 , 0 ) ; + NTT ( x3 , n1 , 0 ) ; + for ( int i = m + 1 ; i <= r ; ++ i ) { + dp[i] = ( dp[i] + f[i - 1] * x2[i - l - 1] % mod ) % mod ; + dp2[i] = ( dp2[i] + f[i - 2] * x3[i - l - 2] % mod ) % mod ; + } + cdq_fz ( m + 1 , r ) ; +} +void preprocess () { + f[0] = invf[0] = 1 ; + dp[0] = dp2[0] = dp2[1] = 1 ; + for ( int i = 1 ; i <= 100000 ; ++ i ) { + f[i] = f[i - 1] * i % mod ; + invf[i] = power ( f[i] , mod - 2 ) ; + if ( i >= 2 ) tcnt[i] = power ( i , i - 2 ) ; + } + tcnt[1] = 1 ; + cdq_fz ( 0 , 100000 ) ; +} +void solve () { + int x ; + scanf ( "%d" , &n ) ; + int ans1 = power ( 2 , n ) , ans2 = 1 ; + for ( int i = 1 ; i <= n ; ++ i ) { + scanf ( "%d" , &x ) ; + ans1 = ans1 * dp[x] % mod ; + if ( n > 2 ) ans2 = ans2 * dp2[x] % mod ; + } + printf ( "%d\n" , ( ans1 - ans2 + mod ) % mod ) ; +} +int main () { + int T ; + preprocess () ; + scanf ( "%d" , &T ) ; + for ( int i = 1 ; i <= T ; ++ i ) { + solve () ; + } + return 0 ; +} diff --git a/HDOJ/5280_autoAC.cpp b/HDOJ/5280_autoAC.cpp new file mode 100644 index 0000000..017c2b1 --- /dev/null +++ b/HDOJ/5280_autoAC.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair PII; +const int N = 1e5 + 7; +const int INF = 0x3f3f3f3f; +const int MOD = 1e9 + 7; +const double EPS = 1e-6; +const double PI = acos(-1.0); +int a[N]; +LL l[N], r[N]; +int main(void){ + int T; + scanf("%d", &T); + while (T--) { + int n, p; + scanf("%d%d", &n, &p); + for (int i = 1; i <= n; ++i) + scanf("%d", &a[i]); + l[0] = r[0] = l[n + 1] = r[n + 1] = 0; + for (int i = 1; i <= n; ++i) + l[i] = max(l[i - 1] + a[i], (LL)a[i]); + for (int i = n; i; --i) + r[i] = max(r[i + 1] + a[i], (LL)a[i]); + LL ans = -INF; + for (int i = 1; i <= n; ++i) { + ans = max(ans, max(l[i - 1], 0LL) + max(r[i + 1], 0LL) + p); + } + for (int i = 1; i < n; ++i) { + ans = max(ans, l[i]); + } + for (int i = n; i > 1; --i) { + ans = max(ans, r[i]); + } + printf("%I64d\n", ans); + } + return 0; +} diff --git a/HDOJ/5281_autoAC.cpp b/HDOJ/5281_autoAC.cpp new file mode 100644 index 0000000..10748fd --- /dev/null +++ b/HDOJ/5281_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#include +using namespace std; +#define maxn 100000 + 10 +#define INF 0x7fffffff +long long mmap[maxn]; +long long temp[maxn]; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + int n,m; + scanf("%d %d",&n,&m); + for(int i=0;i=0;i--) + { + if(p>=m) break; + if(mmap[i] >= temp[p]) + { + ans += mmap[i] - temp[p]; + sum = max(sum,ans); + p++; + } + else + { + p++; + i++; + } + } + printf("%lld\n",sum); + } + return 0; +} diff --git a/HDOJ/5282_autoAC.cpp b/HDOJ/5282_autoAC.cpp new file mode 100644 index 0000000..a1bf475 --- /dev/null +++ b/HDOJ/5282_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +#include +using namespace std; +#define MAX_N 1100 +char a[MAX_N],b[MAX_N]; +int dp[MAX_N+1][MAX_N+1]; +int dd[MAX_N+1][MAX_N+1]; +int wei[MAX_N+1][26]; +__int64 f[MAX_N+1][MAX_N+1]; +int mod=1e9+7; +int main() +{ + int n,m,tem,t; + scanf("%d",&t); + while(t--) + { + scanf("%s%s",a,b); + memset(dp,0,sizeof(dp)); + n=strlen(a); + m=strlen(b); + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int MAXN=100000+100; +const LL LL_INF=numeric_limits::max(); +#define lson L,mid,rt<<1 +#define rson mid+1,R,rt<<1|1 +long long X[4],Y[4]; +long long tx[MAXN],ty[MAXN]; +struct Tree { + long long maX[4],maY[4],addx,addy,sum[4]; +}tr[MAXN<<2]; +void pushup(int rt){ + for(int i=0;i<4;i++){ + tr[rt].maX[i]=max(tr[rt<<1].maX[i],tr[rt<<1|1].maX[i]); + tr[rt].maY[i]=max(tr[rt<<1].maY[i],tr[rt<<1|1].maY[i]); + tr[rt].sum[i]=tr[rt<<1].sum[i]+tr[rt<<1|1].sum[i]; + } +} +void pushdown(int rt){ + if(tr[rt].addx){ + tr[rt<<1].addx+=tr[rt].addx; + tr[rt<<1|1].addx+=tr[rt].addx; + for(int i=0;i<4;i++){ + tr[rt<<1].maX[i]+=tr[rt].addx; + tr[rt<<1|1].maX[i]+=tr[rt].addx; + } + tr[rt].addx=0; + } + if(tr[rt].addy){ + tr[rt<<1].addy+=tr[rt].addy; + tr[rt<<1|1].addy+=tr[rt].addy; + for(int i=0;i<4;i++){ + tr[rt<<1].maY[i]+=tr[rt].addy; + tr[rt<<1|1].maY[i]+=tr[rt].addy; + } + tr[rt].addy=0; + } +} +void build(int L,int R,int rt){ + tr[rt].addy=tr[rt].addx=0; + if(L==R){ + for(int i=0;i<4;i++){ + tr[rt].maX[i]=tx[L]; + tr[rt].maY[i]=ty[L]; + tr[rt].sum[i]=1; + } + return ; + } + int mid=(L+R)>>1; + build(lson); + build(rson); + pushup(rt); +} +void update(int L,int R,int rt,int l,int r,long long v,int flag){ + if(l<=L&&R<=r){ + if(flag==0){ + for(int i=0;i<4;i++) tr[rt].maX[i]+=v; + tr[rt].addx+=v; + } + else { + for(int i=0;i<4;i++) tr[rt].maY[i]+=v; + tr[rt].addy+=v; + } + return ; + } + pushdown(rt); + int mid=(L+R)>>1; + if(l<=mid)update(lson,l,r,v,flag); + if(r>mid)update(rson,l,r,v,flag); + pushup(rt); +} +void adjust(int L,int R,int rt){ + int mid=(L+R)>>1; + for(int i=0;i<4;i++){ + if(tr[rt].maX[i]>X[i]||tr[rt].maY[i]>Y[i]){ + if(L==R){ + tr[rt].maX[i]=LL_INF+1; + tr[rt].maY[i]=LL_INF+1; + tr[rt].sum[i]=0; + continue; + } + pushdown(rt); + adjust(lson);adjust(rson); + pushup(rt); + } + } +} +LL query(int L,int R,int rt,int l,int r,int f){ + if(l<=L&&R<=r)return tr[rt].sum[f]; + int mid=(L+R)>>1; + LL ans=0; + if(l<=mid)ans+=query(lson,l,r,f); + if(r>mid)ans+=query(rson,l,r,f); + return ans; +} +int main() +{ + int n,m,t; + int xx1,xx2,yy1,yy2; + scanf("%d",&t); + while(t--){ + scanf("%d",&n); + scanf("%d%d%d%d",&xx1,&yy1,&xx2,&yy2); + X[0]=xx2;Y[0]=yy2; + X[1]=xx1-1;Y[1]=yy2; + X[2]=xx2;Y[2]=yy1-1; + X[3]=xx1-1;Y[3]=yy1-1; + for(int i=1;i<=n;i++){ + scanf("%I64d%I64d",&tx[i],&ty[i]); + } + build(1,n,1); + int type,d,tl,tr; + scanf("%d",&m); + while(m--){ + scanf("%d",&type); + if(type==1){ + scanf("%d%d%d",&tl,&tr,&d); + update(1,n,1,tl,tr,(LL)d,0); + } + if(type==2){ + scanf("%d%d%d",&tl,&tr,&d); + update(1,n,1,tl,tr,(LL)d,1); + } + if(type==3){ + adjust(1,n,1); + scanf("%d%d",&tl,&tr); + LL ans=query(1,n,1,tl,tr,0)-query(1,n,1,tl,tr,1)-query(1,n,1,tl,tr,2)+query(1,n,1,tl,tr,3); + printf("%I64d\n",ans); + } + } + } + return 0; +} diff --git a/HDOJ/5284_autoAC.cpp b/HDOJ/5284_autoAC.cpp new file mode 100644 index 0000000..7a24e34 --- /dev/null +++ b/HDOJ/5284_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define exp 1e-10 +using namespace std; +const int N = 3145750; +const int inf = 1000000000; +char s[N]; +int main() +{ + int t,i; + scanf("%d",&t); + while(t--) + { + scanf("%s",s); + for(i=0;s[i+1]!='\0';i++) + if(s[i]=='w'||s[i]=='v'&&s[i+1]=='v') + break; + if(s[i+1]=='\0') + { + puts("No"); + continue; + } + for(;s[i]!='\0';i++) + if(s[i]=='y') + break; + if(s[i]=='\0') + { + puts("No"); + continue; + } + for(;s[i]!='\0';i++) + if(s[i]=='h') + break; + if(s[i]=='\0') + puts("No"); + else + puts("Yes"); + } + return 0; +} diff --git a/HDOJ/5285_autoAC.cpp b/HDOJ/5285_autoAC.cpp new file mode 100644 index 0000000..c8b41a2 --- /dev/null +++ b/HDOJ/5285_autoAC.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +using namespace std; +int vis[100005]; +vector v[100005]; +int bfs(int u) +{ + queue q; + q.push(u); + vis[u] = 0; + int res[2] = {1, 0}; + while(!q.empty()) + { + int tmp = q.front(); + q.pop(); + int len = v[tmp].size(); + for(int i = 0; i < len; i++) + { + if(vis[v[tmp][i]] == -1) + { + vis[v[tmp][i]] = !vis[tmp]; + q.push(v[tmp][i]); + res[vis[v[tmp][i]]]++; + } + else if(vis[v[tmp][i]] == vis[tmp]) + return -1; + } + } + return max(res[0], res[1]); +} +int main() +{ + int T; + while(~scanf("%d", &T)) + { + while(T--) + { + int n, m; + for(int i = 0; i < 100005; i++) + v[i].clear(); + memset(vis, -1, sizeof vis); + scanf("%d%d", &n, &m); + for(int i = 0; i < m; i++) + { + int a, b; + scanf("%d%d", &a, &b); + v[a].push_back(b); + v[b].push_back(a); + } + int ans = 0; + for(int j = 1; j <= n; j++) + { + if(vis[j] == -1) + { + int tmp = bfs(j); + if(tmp == -1) + { + ans = -1; + break; + } + else + { + ans += tmp; + } + } + } + if(ans == -1 || (ans == n && n < 2)) + { + puts("Poor wyh"); + } + else if(ans != n) + printf("%d %d\n", ans, n - ans); + else + printf("%d %d\n", ans - 1, n - ans + 1); + } + } + return 0; +} diff --git a/HDOJ/5286_autoAC.cpp b/HDOJ/5286_autoAC.cpp new file mode 100644 index 0000000..9ab7233 --- /dev/null +++ b/HDOJ/5286_autoAC.cpp @@ -0,0 +1,176 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=51005; +const int mod=1000000007; +struct pi{ + int sum; + int lson; + int rson; +}pp[maxn*17]; +int root[maxn],tot; +void build(int cnt,int l,int r){ + pp[cnt].sum=0; + if(l==r) return; + pp[cnt].lson=tot+1; + tot++; + build(tot,l,(l+r)/2); + pp[cnt].rson=tot+1; + tot++; + build(tot,(l+r)/2+1,r); +} +void merg(int qq,int cnt,int n,int p,int k){ + int le,ri,mid; + le=1; + ri=n; + while(le<=ri){ + mid=(le+ri)/2; + pp[cnt]=pp[qq]; + pp[cnt].sum+=k; + if (le==ri) break; + if(p<=mid){ + pp[cnt].lson=tot+1; + tot++; + ri=mid; + cnt=tot; + qq=pp[qq].lson; + } + else{ + pp[cnt].rson=tot+1; + tot++; + le=mid+1; + cnt=tot; + qq=pp[qq].rson; + } + } +} +int query(int cnt,int le,int ri,int l,int r){ + int s=0; + int mid; + if(le>=l&&ri<=r){ + return pp[cnt].sum; + } + mid=(le+ri)/2; + if(l<=mid) s+=query(pp[cnt].lson,le,mid,l,r); + if(r>mid) s+=query(pp[cnt].rson,mid+1,ri,l,r); + return s; +} +int a[maxn],b[maxn],c[maxn]; +int l[maxn],vis[maxn],r[505],le[505]; +int g[315][315]; +vectorgg[maxn],g1; +int d[maxn][300]; +int main() +{ + int i,j,n,m,t; + cin>>t; + while(t--){ + scanf("%d%d",&n,&m); + memset(vis,0,sizeof(vis)); + for(i=1;i<=n;i++){ + scanf("%d",&a[i]); + b[i]=a[i]; + gg[i].clear(); + } + sort(b+1,b+1+n); + memset(d,0,sizeof(d)); + for(i=1;i<=n;i++){ a[i]=lower_bound(b+1,b+1+n,a[i])-b; + vis[a[i]]++; + } + for(i=1;i<=n;i++){ + long long q=1; + gg[i].push_back(0); + for(j=1;j<=vis[i];j++){ + q=q*b[i]; + q%=mod; + gg[i].push_back(q); + } + } + int p=sqrt(n),f=0; + for(i=1;i<=n;i++){ + f++; + int q=min(i+p-1,n); + r[f]=q; + le[f]=i; + for(j=1;j<=n;j++){ + d[j][f]=d[j][f-1]; + } + for(j=i;j<=q;j++){ + l[j]=f; + d[a[j]][f]++; + } + i=q; + } + memset(g,0,sizeof(g)); + for(i=1;i<=n;i++){ + memset(vis,0,sizeof(vis)); + for(j=i;j<=n;j++){ + vis[a[j]]++; + if(j==i||l[j]!=l[j-1]){ + g[l[i]][l[j]]=(g[l[i]][l[j]-1]+gg[a[j]][vis[a[j]]])%mod-gg[a[j]][vis[a[j]]-1]; + g[l[i]][l[j]]%=mod; + } + else{ + g[l[i]][l[j]]+=(gg[a[j]][vis[a[j]]]-gg[a[j]][vis[a[j]]-1])%mod; + g[l[i]][l[j]]%=mod; + } + } + i+=p-1; + } + memset(vis,0,sizeof(vis)); + int la=0; + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int num[100010]; +int zuo[100010]; +int you[100010]; +int has[10010]; +int Scan() +{ + int res = 0, ch, flag = 0; + if((ch = getchar()) == '-') + flag = 1; + else if(ch >= '0' && ch <= '9') + res = ch - '0'; + while((ch = getchar()) >= '0' && ch <= '9' ) + res = res * 10 + ch - '0'; + return flag ? -res : res; +} +vectormy[10010]; +int main() +{ + int n; + for(int i=1;i<=10000;i++) + { + for(int j=1;j<=i;j++) + { + if(i%j==0) + { + my[i].push_back(j); + } + } + } + while(scanf("%d",&n)!=EOF) + { + for(int i=1;i<=n;i++) + { + num[i]=Scan(); + } + memset(zuo,-1,sizeof zuo); + memset(you,-1,sizeof you); + /* + memset(has,0,sizeof has); + for(int i=1;i<=n;i++) + { + if(has[num[i]]!=0) + zuo[i]=has[num[i]]+1; + has[num[i]]=i; + } + memset(has,0,sizeof has); + for(int i=n;i>=1;i--) + { + if(has[num[i]]!=0) + you[i]=has[num[i]]-1; + has[num[i]]=i; + } + */ + memset(has,0,sizeof has); + for(int i=1;i<=n;i++) + { + for(int j=0;j=1;i--) + { + for(int j=0;j +#include +#include +#include +using namespace std; +int a[100005]; +multiset s; +int main() +{ + int T; + scanf("%d", &T); + int n, k; + while(T--) { + s.clear(); + scanf("%d %d", &n, &k); + for(int i = 0; i < n; ++i) { + scanf("%d", &a[i]); + } + if(k == 0) { + printf("0\n"); + continue; + } + s.insert(a[0]); + int l = 0, r = 1; + int cnt = 1; + long long ans = 0; + int minn, maxn; + while(1) { + if(s.size()) { + minn = *s.begin(); + maxn = *s.rbegin(); + if(abs(a[r]-minn) < k && abs(a[r]-maxn) < k) { + ans += (long long)s.size(); + s.insert(a[r]); + r++; + if(r == n) break; + } + else { + if(s.size()) { + s.erase(s.find(a[l])); + } + l++; + } + } + else { + l = r; + s.insert(a[r]); + r++; + if(r == n) break; + } + } + printf("%I64d\n", ans+n); + } + return 0; +} diff --git a/HDOJ/5290_autoAC.cpp b/HDOJ/5290_autoAC.cpp new file mode 100644 index 0000000..fb45234 --- /dev/null +++ b/HDOJ/5290_autoAC.cpp @@ -0,0 +1,172 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +#define prt(k) cout<<#k" = "< b.d; + } +}p[N]; +bool vis[N]; +void bfs() +{ + queue

q; + q.push(P(1,0)); + memset(vis,0,sizeof vis); + vis[1] = true; + father[1] = 1; + while (!q.empty()) { + P u = q.front(); q.pop(); + int now = u.id; + p[now].id = now; + p[now].d = u.d + 1; + for (int i=head[now];~i;i=e[i].next) { + int v = e[i].v; + if (!vis[v]) { + q.push(P(v, u.d + 1)); + vis[v] = true; + father[v] = now; + } + } + } +} +void gao(int u, int fa) +{ + assert(!vis[u]); + vis[u] = true; + bool flag = false; + g[u][0] = 0; + for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + flag = true; + g[u][0] += f[v][0]; + assert(vis[v]); + } + if (!flag) { + g[u][0] = 0; + f[u][w[u]] = 1; + } + for (int j=0;j<=maxw;j++) { + ll sum=0; + for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + int t = F[v][j+1]; + if (j > 0) + t = min(t, G[v][j-1]); + sum += t; + if (sum >= n) { sum = n; break; } + } + if (sum < n ) for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + int t = F[v][j+1]; + if (j > 0) t = min(t, G[v][j-1]); + if (0<=sum && sum < n) f[u][j] = min(f[u][j], (int)(f[v][j+1] + sum - t ) ) ; + } + sum = 0; + int t; + for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + int t = F[v][j]; + if (j > 0) t = min(t, G[v][j-1]); + sum += t; + if (sum >= n) { sum = n; break; } + } + if (j>0 && sum < n) for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + int t = F[v][j]; + if (j > 0) t = min(t, G[v][j-1]); + if (0<=sum && sum < n) g[u][j]=min(g[u][j], (int)(g[v][j-1] + sum - t ) ); + } + } + ll sum = 0; + for (int i=head[u];~i;i=e[i].next) { + int v = e[i].v; + if (v==fa) continue; + sum += min(F[v][w[u]+1], w[u]>0 ? G[v][w[u]-1] : n); + } + if (0<=sum && sum=0;i--) f[u][i] = min(f[u][i], f[u][i+1]); + for (int i=1;i<=100;i++) g[u][i] = min(g[u][i], g[u][i-1]); + F[u][0] = f[u][0]; + G[u][0] = g[u][0]; + for (int j=1;j<=maxw+1;j++) { + F[u][j] = min(F[u][j-1], f[u][j]); + G[u][j] = min(G[u][j-1], g[u][j]); + } +} +int main() +{ + while (scanf("%d", &n)==1) { + maxw = 0; + for (int i=1;i<=n;i++) scanf("%d", w+i), maxw=max(maxw, w[i]); + mm=0; memset(head,-1,sizeof head); + for (int i=1;i<=n-1;i++) + { + int u, v; scanf("%d%d", &u, &v); + add(u, v); + add(v, u); + } + memset(f, 63, sizeof f); + memset(g, 63, sizeof g); + bfs(); + sort(p+1, p+n+1); + memset(vis, 0, sizeof vis); + for (int i=1;i<=n;i++) { + gao(p[i].id, father[p[i].id]); + } + int ans = n; + for (int i=0;i<=maxw;i++) + ans = min(ans, f[1][i]); + printf("%d\n", ans); + } +} diff --git a/HDOJ/5291_autoAC.cpp b/HDOJ/5291_autoAC.cpp new file mode 100644 index 0000000..be1d4ef --- /dev/null +++ b/HDOJ/5291_autoAC.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +using namespace std; +#define ll long long +int dp[90000],sum[2][90000]; +int mod = 1000000007; +int modx = -mod; +int num[300]; +int main(){ + int t,n; + scanf("%d",&t); + while(t--){ + scanf("%d",&n); + int total = 0; + for(int i = 1; i <= n; i++){ + scanf("%d",&num[i]); + total += num[i]; + } + if(total & 1) total++; + memset(dp,0,sizeof(dp)); + memset(sum,0,sizeof(sum)); + dp[total] = 1; + int tt = total*2; + for(int i = 1; i <= n; i++){ + sum[0][0] = dp[0]; + sum[1][0] = 0; + for(int j = 1;j <= tt; j++){ + sum[0][j] = sum[0][j-1]; + sum[1][j] = sum[1][j-1]; + sum[j&1][j] += dp[j]; + sum[j&1][j] %= modx; + } + ll ans = 0; + for(int j = 0;j <= num[i]; j++){ + ans += (ll)dp[j]*((num[i]-j)/2+1); + ans %= mod; + } + int p = (num[i]&1)^1; + int res = ans; + for(int j = 0;j <= tt; j++){ + dp[j] = res; + int u = j-num[i]-1; + u = max(u,0); + res += (sum[p][j+1+num[i]] - sum[p][j])%mod; + res %= mod; + p ^= 1; + res -= (sum[p][j] - sum[p][u])%mod; + res %= mod; + } + } + int res = dp[total]; + res %= mod; + res = (res+mod)%mod; + cout< +#include +#include +#include +#include +#include +#include +using namespace std; +#define ll long long +int main(){ + int t; + cin>>t; + int cas=0; + while(t--){ + cas++; + int ans=0; + for(int i=1;i<=24;i++){ + char color[2]; + scanf("%s",color); + if(color[0]=='w'||color[0]=='y'){ + switch(i){ + case 5: + case 7: + case 9: + case 12: + case 14: + case 16: + case 21: + case 24: + ans++; + break; + case 6: + case 8: + case 10: + case 11: + case 13: + case 15: + case 22: + case 23: + ans+=2; + break; + } + } + } + printf("Case #%d: ",cas); + if(ans%3==0){ + printf("YES\n"); + }else{ + printf("NO\n"); + } + } + return 0; +} diff --git a/HDOJ/5293_autoAC.cpp b/HDOJ/5293_autoAC.cpp new file mode 100644 index 0000000..c863947 --- /dev/null +++ b/HDOJ/5293_autoAC.cpp @@ -0,0 +1,74 @@ +#pragma comment(linker,"/STACK:102400000,102400000") +#include +#include +#include +#include +#include +#include +#define ll int +using namespace std; +const int maxn = 100000+10; +int t,n,m; +vector g[maxn]; +int fa[maxn][25],deep[maxn]; +int cnt,l[maxn],r[maxn]; +vector lis[maxn]; +void dfs(int u,int f,int d){ + l[u]=++cnt,deep[u]=d,fa[u][0]=f; + for(int i=0;i=0;j--) if (fa[x][j] != fa[y][j]) x = fa[x][j], y = fa[y][j]; + return fa[x][0]; +} +int st[maxn],en[maxn],quan[maxn]; +int dp[maxn],sum[maxn],sd[maxn<<1],ss[maxn<<1]; +int lowbit(int x) { return x&(-x); } +void Add(int id,int x,int c[]) { for(int i=id;i<=2*n;i+=lowbit(i)) c[i]+=x; } +int Sum(int id,int c[]) { int tmp=0; for(int i=id;i>0;i-=lowbit(i)) tmp+=c[i]; return tmp; } +void dfs2(int u,int f){ + for(int i=0;i +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int INF=0x3f3f3f3f; +const int MAXN=2010; +int N,M; +struct Edge{ + int from,to,cap,flow; +}; +struct Dinic{ + int n,m,s,t; + vector edges; + vector G[MAXN]; + bool vis[MAXN]; + int d[MAXN]; + int cur[MAXN]; + void clear_all(int n){ + for(int i=0;i q; + q.push(s); + d[s]=0; + vis[s]=1; + while(!q.empty()){ + int x=q.front(); + q.pop(); + int len=G[x].size(); + for(int i=0;ie.flow){ + vis[e.to]=1; + d[e.to]=d[x]+1; + q.push(e.to); + } + } + } + return vis[t]; + } + int DFS(int x,int a){ + if(x==t||a==0) return a; + int flow=0,f,len=G[x].size(); + for(int& i=cur[x];i0){ + e.flow+=f; + edges[G[x][i]^1].flow-=f; + flow+=f; + a-=f; + if(a==0) break; + } + } + return flow; + } + int maxflow(int s,int t){ + this->s=s; + this->t=t; + int flow=0; + while(BFS()){ + memset(cur,0,sizeof(cur)); + flow+=DFS(s,INF); + } + return flow; + } + int mincut(){ + int ans=0; + int len=edges.size(); + for(int i=0;i0) ans++; + } + return ans; + } + void reduce(){ + int len=edges.size(); + for(int i=0;i p[MAXN]; +struct HeapNode{ + int u,d; + bool operator < (const HeapNode& rhs) const{ + return d>rhs.d; + } +}; +struct Edge2{ + int u,v,dist; +}; +struct Dijkstra{ + int n,m; + vector edges; + vector G[MAXN]; + bool done[MAXN]; + void init(int n){ + this->n=n; + for(int i=0;i q; + for(int i=0;id[u]+e.dist){ + d[e.v]=d[u]+e.dist; + p[e.v].clear(); + p[e.v].push_back(u); + q.push((HeapNode){e.v,d[e.v]}); + } + else if(d[e.v]==d[u]+e.dist){ + p[e.v].push_back(u); + q.push((HeapNode){e.v,d[e.v]}); + } + } + } + } +}solver2; +int num[MAXN]; +int dfs(int u){ + if(u==0) return 0; + if(num[u]!=INF) return num[u]; + int len=p[u].size(); + for(int i=0;i +#include +#include +#include +#include +using namespace std; +const double eps = 1e-6; +int sgn(double x){ +if(fabs(x) <= eps) return 0; +return x > 0 ? 1 : -1; +} +struct P{ +double x , y; +P(double _x = 0,double _y = 0){ +x = _x , y = _y; +} +void set(double _x,double _y){ +x = _x , y = _y; +} +void out(){ +printf("%.6lf %.6lf\n",x,y); +} +P operator + (P b){ +return P(x+b.x,y+b.y); +} +P operator - (P b){ +return P(x-b.x,y-b.y); +} +P operator / (double k){ +return P(x/k , y/k); +} +bool operator == (const P&b) const{ +return sgn(x - b.x) == 0 && sgn(y - b.y) == 0; +} +double lenq(){ +return x*x + y*y; +} +double len(){ +return sqrt(lenq()); +} +}; +double dis(P a,P b){ +return (a-b).len(); +} +struct Cir{ +P o; +double r; +Cir(P _o,double _r = 0){ +o = _o , r = _r; +} +void set(P _o,double _r){ +o = _o , r = _r; +} +bool operator == (const Cir&b) const{ +return o == b.o && sgn(r - b.r) == 0; +} +}; +void c2point(Cir c1,Cir c2,P &rp1,P &rp2){ +if(c1 == c2){ +rp1 = c1.o + P(0,c1.r); +rp2 = c1.o - P(0,c1.r); +return; +} +P p1 = c1.o , p2 = c2.o; +double r1 = c1.r , r2 = c2.r; +double a = p2.x - p1.x , b = p2.y - p1.y , r = (a*a + b*b + r1*r1 - r2*r2) / 2; +double tmp; +if(a == 0 && b != 0){ +rp1.y = rp2.y = r / b; +tmp = r1 * r1 - rp1.y * rp1.y; +if(sgn(tmp) <= 0) tmp = 0; +rp1.x = sqrt(tmp); +rp2.x = -rp1.x; +} +else if(a != 0 && b == 0){ +rp1.x = rp2.x = r / a; +tmp = r1 * r1 - rp1.x * rp1.x; +if(sgn(tmp) <= 0) tmp = 0; +rp1.y = sqrt(tmp); +rp2.y = -rp1.y; +} +else if(a != 0 && b != 0){ +double delta = b*b*r*r - (a*a + b*b) * (r*r - r1*r1*a*a); +if(sgn(delta) <= 0) delta = 0; +rp1.y = (b*r + sqrt(delta)) / (a*a + b*b); +rp2.y = (b*r - sqrt(delta)) / (a*a + b*b); +rp1.x = (r - b*rp1.y) / a; +rp2.x = (r - b*rp2.y) / a; +} +rp1.x += p1.x , rp1.y += p1.y; +rp1.x += p1.x , rp2.y += p1.y; +} +int T; +double AB , BC , CD , DA , EF; +P A , B , C , D , A2 , G; +void graph_construct(){ +C.set(0,0); +B.set(BC,0); +Cir O1(C,DA) , O2(B,2 * EF); +P discard; +c2point(O1,O2,A2,discard); +G = A2 + (B - C); +O1.set(C,CD);O2.set(G,AB); +c2point(O1,O2,D,discard); +A = D + (C - A2); +} +const double eps2 = 1e-4; +int sgn2(double x){ +if(fabs(x) <= eps2) return 0; +return 1; +} +void spj(){ +bool ff = true; +if(sgn2(AB - dis(A,B)) != 0) ff = false; +if(sgn2(BC - dis(B,C)) != 0) ff = false; +if(sgn2(CD - dis(C,D)) != 0) ff = false; +if(sgn2(DA - dis(D,A)) != 0) ff = false; +if(sgn2(EF - dis((A+B)/2,(C+D)/2)) != 0) ff = false; +} +int main(){ +scanf("%d",&T); +for(int _=1;_<=T;++_){ +scanf("%lf%lf%lf%lf%lf",&AB,&BC,&CD,&DA,&EF); +graph_construct(); +printf("Case #%d:\n",_); +A.out();B.out();C.out();D.out(); +spj(); +} +return 0; +} diff --git a/HDOJ/5296_autoAC.cpp b/HDOJ/5296_autoAC.cpp new file mode 100644 index 0000000..1027fb1 --- /dev/null +++ b/HDOJ/5296_autoAC.cpp @@ -0,0 +1,156 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define INF 0x3f3f3f3f +#define inf (-((LL)1<<40)) +#define lson k<<1, L, (L + R)>>1 +#define rson k<<1|1, ((L + R)>>1) + 1, R +#define mem0(a) memset(a,0,sizeof(a)) +#define mem1(a) memset(a,-1,sizeof(a)) +#define mem(a, b) memset(a, b, sizeof(a)) +#define rep(i, a, b) for(int i = (a); i <= (b); i ++) +#define dec(i, a, b) for(int i = (a); i >= (b); i --) +template T MAX(T a, T b) { return a > b ? a : b; } +template T MIN(T a, T b) { return a < b ? a : b; } +template T GCD(T a, T b) { return b ? GCD(b, a%b) : a; } +template T LCM(T a, T b) { return a / GCD(a,b) * b; } +typedef long long LL; +const int MAXN = 100000 + 100; +const int MAXM = 2000000 + 100; +const double eps = 1e-8; +LL MOD = 1000000007; +struct Edge { + int v, w; + Edge(int _v = 0, int _w = 0) { + v = _v; w = _w; + } +}; +struct LCA { + int idx[MAXN << 1]; + int dep[MAXN << 1]; + int dp[MAXN << 1][20]; + int K[MAXN << 1]; + int node_cnt; + vectorG[MAXN]; + int P[MAXN]; + int dis[MAXN]; + void init(int n) { + mem0(dep); mem0(K); + node_cnt = 0; + rep (i, 0, n) G[i].clear(); + } + void add_edge(int u, int v, int w) { + G[u].push_back(Edge(v, w)); + G[v].push_back(Edge(u, w)); + } + void dfs(int u, int fa, int height, int dist) { + idx[++node_cnt] = u; + dep[node_cnt] = height; + P[u] = node_cnt; + dis[u] = dist; + int sz = G[u].size(); + rep (i, 0, sz - 1) { + int v = G[u][i].v; + if(v == fa) continue; + dfs(v, u, height + 1, dist + G[u][i].w); + idx[++node_cnt] = u; + dep[node_cnt] = height; + } + } + void init_st_table() { + dfs(1, -1, 0, 0); + int n = node_cnt; + rep (i, 1, n) { + dp[i][0] = i; + while((1 << (K[i] + 1)) <= i) K[i] ++; + } + for(int j = 1; (1 << j) <= n; j ++) { + for(int i = 1; i + (1 << j) - 1 <= n; i ++) { + int l_pos = dp[i][j - 1], r_pos = dp[i + (1 << (j - 1))][j - 1]; + dp[i][j] = dep[l_pos] < dep[r_pos] ? l_pos : r_pos; + } + } + } + int rmq_query(int L, int R) { + if(L > R) swap(L, R); + int len = R - L + 1, k = K[len]; + return dep[dp[L][k]] < dep[dp[R - (1 << k) + 1][k]] ? dp[L][k] : dp[R - (1 << k) + 1][k]; + } + int lca_query(int u, int v) { + int id = rmq_query(P[u], P[v]); + return idx[id]; + } +}lca; +struct SegTree { + int s[MAXN << 3]; + void update(int k, int L, int R, int p, int v) { + if(L == R) { s[k] = v; return ; } + if(((L + R) >> 1) >= p) update(lson, p, v); + else update(rson, p, v); + s[k] = s[k << 1] + s[k << 1 | 1]; + } + int query_sum(int k, int L, int R, int p) { + if(R <= p) return s[k]; + if( ((L + R) >> 1) >= p ) return query_sum(lson, p); + return s[k << 1] + query_sum(rson, p); + } + int query_pos(int k, int L, int R, int x) { + if(L == R) return L; + if(s[k << 1] >= x) return query_pos(lson, x); + return query_pos(rson, x - s[k << 1]); + } +}st; +int t, n, m, cas = 0; +int u, v, w; +bool vis[MAXN << 1]; +int main() +{ + cin >> t; + while(t--) { + scanf("%d %d", &n, &m); + lca.init(n); + rep (i, 2, n) { + scanf("%d %d %d", &u, &v, &w); + lca.add_edge(u, v, w); + } + lca.init_st_table(); + mem0(st.s); + mem0(vis); + int ans = 0; + printf("Case #%d:\n", ++cas); + while(m --) { + scanf("%d %d", &u, &v); + if( (u == 1 && !vis[v]) || (u == 2 && vis[v]) ) { + vis[v] = !vis[v]; + if(u == 2) st.update(1, 1, lca.node_cnt, lca.P[v], 0); + if( st.s[1] ) { + int x, y; + int sum = st.query_sum(1, 1, lca.node_cnt, lca.P[v]); + if( !sum || sum == st.s[1] ) x = 1, y = st.s[1]; + else x = sum, y = sum + 1; + x = lca.idx[st.query_pos(1, 1, lca.node_cnt, x)]; + y = lca.idx[st.query_pos(1, 1, lca.node_cnt, y)]; + int xv = lca.lca_query(x, v); + int yv = lca.lca_query(y, v); + int xy = lca.lca_query(x, y); + ans += (u == 1 ? 1 : -1) * (lca.dis[v] - lca.dis[xv] - lca.dis[yv] + lca.dis[xy]); + } + else ans = 0; + if(u == 1) st.update(1, 1, lca.node_cnt, lca.P[v], 1); + } + printf("%d\n", ans); + } + } + return 0; +} diff --git a/HDOJ/5297_autoAC.cpp b/HDOJ/5297_autoAC.cpp new file mode 100644 index 0000000..168c547 --- /dev/null +++ b/HDOJ/5297_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +using namespace std; +int prime[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67}; +int cnt[100]={19,0,1,1,1,1,2,1,1,1,2,1,2,1,2,2,1,1,2,1,2,2,2,1,2,1,2,1,2,1,3,1,1,2,2,2,2,1,2,2 +,2,1,3,1,2,2,2,1,2,1,2,2,2,1,2,2,2,2,2,1,3,1,2,2,1}; +long long considrt[6000000],nconsidrt; +void GetConsider(int r) +{ + nconsidrt=0; + int i,j,sz; + for(i=0;prime[i]<=r;i++) + { + sz=nconsidrt; + for(j=0;j +typedef long long LL ; +struct Node { + LL x , y , z , d ; +} a[100] , b[10] ; +int n , m , p , q ; +LL f ( LL x ) { + return ( LL ) x * x ; +} +bool calc ( int x , int y , int z ) { + bool t = 0 ; + for ( int i = 0 ; i < n ; ++ i ) if ( a[i].x * x + a[i].y * y + a[i].z * z + a[i].d > 0 ) t ^= 1 ; + for ( int i = 0 ; i < m ; ++ i ) if ( f ( b[i].d ) > f ( b[i].x - x ) + f ( b[i].y - y ) + f ( b[i].z - z ) ) t ^= 1 ; + return t ; +} +void solve () { + int x , y , z , ok = 1 , mark = -1 ; + scanf ( "%d%d%d%d" , &n , &m , &p , &q ) ; + for ( int i = 0 ; i < n ; ++ i ) scanf ( "%lld%lld%lld%lld" , &a[i].x , &a[i].y , &a[i].z , &a[i].d ) ; + for ( int i = 0 ; i < m ; ++ i ) scanf ( "%lld%lld%lld%lld" , &b[i].x , &b[i].y , &b[i].z , &b[i].d ) ; + for ( int i = 0 ; i < p ; ++ i ) { + scanf ( "%d%d%d" , &x , &y , &z ) ; + if ( !ok ) continue ; + bool tmp = calc ( x , y , z ) ; + if ( mark == -1 ) mark = tmp ; + else if ( mark != tmp ) ok = 0 ; + } + if ( !ok ) puts ( "Impossible" ) ; + for ( int i = 0 ; i < q ; ++ i ) { + scanf ( "%d%d%d" , &x , &y , &z ) ; + if ( !ok ) continue ; + bool tmp = calc ( x , y , z ) ; + if ( mark == -1 ) puts ( "Both" ) ; + else puts ( mark == tmp ? "Y" : "R" ) ; + } +} +int main () { + int T ; + scanf ( "%d" , &T ) ; + for ( int i = 1 ; i <= T ; ++ i ) { + if ( i > 1 ) puts ( "" ) ; + solve () ; + } + return 0 ; +} diff --git a/HDOJ/5299_autoAC.cpp b/HDOJ/5299_autoAC.cpp new file mode 100644 index 0000000..5f5c7f7 --- /dev/null +++ b/HDOJ/5299_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +struct Point +{ + int x,y,r; +}point[20010]; +bool cmp(Point a,Point b) +{ + return a.rll(point[i].x-point[j].x)*(point[i].x-point[j].x)+(point[i].y-point[j].y)*(point[i].y-point[j].y)) + { + flag=1; + add(j,i); + break; + } + if(!flag) + add(n,i); + } + if(dfs(n)!=0) + puts("Alice"); + else + puts("Bob"); + } +}