From dd3af96771f1175b5bbf73d2e7d0eb2945c1f79f Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Sat, 10 Sep 2016 11:34:41 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 4900-4999 --- HDOJ/4900_autoAC.cpp | 102 ++++++++++++++++ HDOJ/4901_autoAC.cpp | 62 ++++++++++ HDOJ/4902_autoAC.cpp | 139 +++++++++++++++++++++ HDOJ/4906_autoAC.cpp | 41 +++++++ HDOJ/4907_autoAC.cpp | 82 +++++++++++++ HDOJ/4908_autoAC.cpp | 37 ++++++ HDOJ/4909_autoAC.cpp | 81 ++++++++++++ HDOJ/4910_autoAC.cpp | 164 +++++++++++++++++++++++++ HDOJ/4911_autoAC.cpp | 48 ++++++++ HDOJ/4912_autoAC.cpp | 115 ++++++++++++++++++ HDOJ/4913_autoAC.cpp | 124 +++++++++++++++++++ HDOJ/4914_autoAC.cpp | 125 +++++++++++++++++++ HDOJ/4915_autoAC.cpp | 87 +++++++++++++ HDOJ/4916_autoAC.cpp | 120 ++++++++++++++++++ HDOJ/4917_autoAC.cpp | 103 ++++++++++++++++ HDOJ/4918_autoAC.cpp | 204 +++++++++++++++++++++++++++++++ HDOJ/4920_autoAC.cpp | 42 +++++++ HDOJ/4921_autoAC.cpp | 69 +++++++++++ HDOJ/4923_autoAC.cpp | 89 ++++++++++++++ HDOJ/4924_autoAC.cpp | 144 ++++++++++++++++++++++ HDOJ/4925_autoAC.cpp | 57 +++++++++ HDOJ/4927_autoAC.cpp | 244 +++++++++++++++++++++++++++++++++++++ HDOJ/4928_autoAC.cpp | 63 ++++++++++ HDOJ/4929_autoAC.cpp | 146 ++++++++++++++++++++++ HDOJ/4930_autoAC.cpp | 149 +++++++++++++++++++++++ HDOJ/4931_autoAC.cpp | 21 ++++ HDOJ/4932_autoAC.cpp | 76 ++++++++++++ HDOJ/4933_autoAC.cpp | 239 ++++++++++++++++++++++++++++++++++++ HDOJ/4937_autoAC.cpp | 69 +++++++++++ HDOJ/4938_autoAC.cpp | 137 +++++++++++++++++++++ HDOJ/4939_autoAC.cpp | 32 +++++ HDOJ/4940_autoAC.cpp | 130 ++++++++++++++++++++ HDOJ/4941_autoAC.cpp | 67 ++++++++++ HDOJ/4942_autoAC.cpp | 138 +++++++++++++++++++++ HDOJ/4944_autoAC.cpp | 48 ++++++++ HDOJ/4945_autoAC.cpp | 110 +++++++++++++++++ HDOJ/4946_autoAC.cpp | 96 +++++++++++++++ HDOJ/4947_autoAC.cpp | 104 ++++++++++++++++ HDOJ/4948_autoAC.cpp | 64 ++++++++++ HDOJ/4949_autoAC.cpp | 109 +++++++++++++++++ HDOJ/4950_autoAC.cpp | 13 ++ HDOJ/4952_autoAC.cpp | 27 ++++ HDOJ/4955_autoAC.cpp | 97 +++++++++++++++ HDOJ/4956_autoAC.cpp | 46 +++++++ HDOJ/4958_autoAC.cpp | 53 ++++++++ HDOJ/4959_autoAC.cpp | 139 +++++++++++++++++++++ HDOJ/4960_autoAC.cpp | 69 +++++++++++ HDOJ/4961_autoAC.cpp | 66 ++++++++++ HDOJ/4962_autoAC.cpp | 123 +++++++++++++++++++ HDOJ/4963_autoAC.cpp | 136 +++++++++++++++++++++ HDOJ/4964_autoAC.cpp | 134 ++++++++++++++++++++ HDOJ/4965_autoAC.cpp | 98 +++++++++++++++ HDOJ/4966_autoAC.cpp | 110 +++++++++++++++++ HDOJ/4967_autoAC.cpp | 112 +++++++++++++++++ HDOJ/4968_autoAC.cpp | 49 ++++++++ HDOJ/4969_autoAC.cpp | 17 +++ HDOJ/4970_autoAC.cpp | 32 +++++ HDOJ/4971_autoAC.cpp | 252 ++++++++++++++++++++++++++++++++++++++ HDOJ/4972_autoAC.cpp | 43 +++++++ HDOJ/4973_autoAC.cpp | 165 +++++++++++++++++++++++++ HDOJ/4974_autoAC.cpp | 15 +++ HDOJ/4975_autoAC.cpp | 164 +++++++++++++++++++++++++ HDOJ/4976_autoAC.cpp | 56 +++++++++ HDOJ/4977_autoAC.cpp | 184 ++++++++++++++++++++++++++++ HDOJ/4978_autoAC.cpp | 88 ++++++++++++++ HDOJ/4979_autoAC.cpp | 78 ++++++++++++ HDOJ/4980_autoAC.cpp | 79 ++++++++++++ HDOJ/4981_autoAC.cpp | 24 ++++ HDOJ/4982_autoAC.cpp | 50 ++++++++ HDOJ/4983_autoAC.cpp | 76 ++++++++++++ HDOJ/4984_autoAC.cpp | 117 ++++++++++++++++++ HDOJ/4985_autoAC.cpp | 29 +++++ HDOJ/4986_autoAC.cpp | 19 +++ HDOJ/4987_autoAC.cpp | 41 +++++++ HDOJ/4988_autoAC.cpp | 247 +++++++++++++++++++++++++++++++++++++ HDOJ/4989_autoAC.cpp | 30 +++++ HDOJ/4990_autoAC.cpp | 58 +++++++++ HDOJ/4991_autoAC.cpp | 52 ++++++++ HDOJ/4992_autoAC.cpp | 169 +++++++++++++++++++++++++ HDOJ/4993_autoAC.cpp | 19 +++ HDOJ/4994_autoAC.cpp | 37 ++++++ HDOJ/4995_autoAC.cpp | 66 ++++++++++ HDOJ/4996_autoAC.cpp | 69 +++++++++++ HDOJ/4997_autoAC.cpp | 93 ++++++++++++++ HDOJ/4998_autoAC.cpp | 89 ++++++++++++++ HDOJ/4999_autoAC.cpp | 284 +++++++++++++++++++++++++++++++++++++++++++ 86 files changed, 8091 insertions(+) create mode 100644 HDOJ/4900_autoAC.cpp create mode 100644 HDOJ/4901_autoAC.cpp create mode 100644 HDOJ/4902_autoAC.cpp create mode 100644 HDOJ/4906_autoAC.cpp create mode 100644 HDOJ/4907_autoAC.cpp create mode 100644 HDOJ/4908_autoAC.cpp create mode 100644 HDOJ/4909_autoAC.cpp create mode 100644 HDOJ/4910_autoAC.cpp create mode 100644 HDOJ/4911_autoAC.cpp create mode 100644 HDOJ/4912_autoAC.cpp create mode 100644 HDOJ/4913_autoAC.cpp create mode 100644 HDOJ/4914_autoAC.cpp create mode 100644 HDOJ/4915_autoAC.cpp create mode 100644 HDOJ/4916_autoAC.cpp create mode 100644 HDOJ/4917_autoAC.cpp create mode 100644 HDOJ/4918_autoAC.cpp create mode 100644 HDOJ/4920_autoAC.cpp create mode 100644 HDOJ/4921_autoAC.cpp create mode 100644 HDOJ/4923_autoAC.cpp create mode 100644 HDOJ/4924_autoAC.cpp create mode 100644 HDOJ/4925_autoAC.cpp create mode 100644 HDOJ/4927_autoAC.cpp create mode 100644 HDOJ/4928_autoAC.cpp create mode 100644 HDOJ/4929_autoAC.cpp create mode 100644 HDOJ/4930_autoAC.cpp create mode 100644 HDOJ/4931_autoAC.cpp create mode 100644 HDOJ/4932_autoAC.cpp create mode 100644 HDOJ/4933_autoAC.cpp create mode 100644 HDOJ/4937_autoAC.cpp create mode 100644 HDOJ/4938_autoAC.cpp create mode 100644 HDOJ/4939_autoAC.cpp create mode 100644 HDOJ/4940_autoAC.cpp create mode 100644 HDOJ/4941_autoAC.cpp create mode 100644 HDOJ/4942_autoAC.cpp create mode 100644 HDOJ/4944_autoAC.cpp create mode 100644 HDOJ/4945_autoAC.cpp create mode 100644 HDOJ/4946_autoAC.cpp create mode 100644 HDOJ/4947_autoAC.cpp create mode 100644 HDOJ/4948_autoAC.cpp create mode 100644 HDOJ/4949_autoAC.cpp create mode 100644 HDOJ/4950_autoAC.cpp create mode 100644 HDOJ/4952_autoAC.cpp create mode 100644 HDOJ/4955_autoAC.cpp create mode 100644 HDOJ/4956_autoAC.cpp create mode 100644 HDOJ/4958_autoAC.cpp create mode 100644 HDOJ/4959_autoAC.cpp create mode 100644 HDOJ/4960_autoAC.cpp create mode 100644 HDOJ/4961_autoAC.cpp create mode 100644 HDOJ/4962_autoAC.cpp create mode 100644 HDOJ/4963_autoAC.cpp create mode 100644 HDOJ/4964_autoAC.cpp create mode 100644 HDOJ/4965_autoAC.cpp create mode 100644 HDOJ/4966_autoAC.cpp create mode 100644 HDOJ/4967_autoAC.cpp create mode 100644 HDOJ/4968_autoAC.cpp create mode 100644 HDOJ/4969_autoAC.cpp create mode 100644 HDOJ/4970_autoAC.cpp create mode 100644 HDOJ/4971_autoAC.cpp create mode 100644 HDOJ/4972_autoAC.cpp create mode 100644 HDOJ/4973_autoAC.cpp create mode 100644 HDOJ/4974_autoAC.cpp create mode 100644 HDOJ/4975_autoAC.cpp create mode 100644 HDOJ/4976_autoAC.cpp create mode 100644 HDOJ/4977_autoAC.cpp create mode 100644 HDOJ/4978_autoAC.cpp create mode 100644 HDOJ/4979_autoAC.cpp create mode 100644 HDOJ/4980_autoAC.cpp create mode 100644 HDOJ/4981_autoAC.cpp create mode 100644 HDOJ/4982_autoAC.cpp create mode 100644 HDOJ/4983_autoAC.cpp create mode 100644 HDOJ/4984_autoAC.cpp create mode 100644 HDOJ/4985_autoAC.cpp create mode 100644 HDOJ/4986_autoAC.cpp create mode 100644 HDOJ/4987_autoAC.cpp create mode 100644 HDOJ/4988_autoAC.cpp create mode 100644 HDOJ/4989_autoAC.cpp create mode 100644 HDOJ/4990_autoAC.cpp create mode 100644 HDOJ/4991_autoAC.cpp create mode 100644 HDOJ/4992_autoAC.cpp create mode 100644 HDOJ/4993_autoAC.cpp create mode 100644 HDOJ/4994_autoAC.cpp create mode 100644 HDOJ/4995_autoAC.cpp create mode 100644 HDOJ/4996_autoAC.cpp create mode 100644 HDOJ/4997_autoAC.cpp create mode 100644 HDOJ/4998_autoAC.cpp create mode 100644 HDOJ/4999_autoAC.cpp diff --git a/HDOJ/4900_autoAC.cpp b/HDOJ/4900_autoAC.cpp new file mode 100644 index 0000000..dadb194 --- /dev/null +++ b/HDOJ/4900_autoAC.cpp @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 310; +const int INF = 0x3f3f3f3f; +int mat[MAXN][MAXN], dif[MAXN][MAXN]; +int label[MAXN], has[MAXN], tmp[MAXN]; +int n, k, T; +int head[MAXN], ecnt; +int to[MAXN << 1], ne[MAXN << 1]; +void init() { + memset(head + 1, -1, n * sizeof(int)); + ecnt = 0; +} +void add_edge(int u, int v) { + to[ecnt] = v; ne[ecnt] = head[u]; head[u] = ecnt++; + to[ecnt] = u; ne[ecnt] = head[v]; head[v] = ecnt++; +} +int que[MAXN], dis[MAXN]; +void bfs(int st) { + memset(dis + 1, 0x3f, n * sizeof(int)); + int l = 0, r = 0; + dis[que[r++] = st] = 0; + while(l != r) { + int u = que[l++]; + for(int p = head[u]; ~p; p = ne[p]) { + int &v = to[p]; + if(dis[u] + 1 < dis[v]) { + dis[v] = dis[u] + 1; + que[r++] = v; + } + } + } + for(int i = 1; i <= n; ++i) mat[st][i] = dis[i]; +} +int cnt[MAXN]; +void dfs(int u, int f, int& c, int st) { + if(++cnt[has[u]] == 1) c++; + dif[st][u] = c; + for(int p = head[u]; ~p; p = ne[p]) { + int &v = to[p]; + if(v == f) continue; + dfs(v, u, c, st); + } + if(--cnt[has[u]] == 0) c--; +} +double per[MAXN]; +void initPer(int n = 300) { + per[0] = log(1); + for(int i = 1; i <= n; ++i) + per[i] = per[i - 1] + log(i); +} +double c(int n, int k) { + return per[n] - per[n - k] - per[k]; +} +double calc(int a, int b) { + int cnt = 2; + for(int i = 1; i <= n; ++i) { + if(i == a || i == b) continue; + if(mat[i][a] > mat[a][b] || mat[i][b] > mat[a][b]) continue; + if(mat[i][b] == mat[a][b] && i < a) continue; + if(mat[i][a] == mat[a][b] && i < b) continue; + cnt++; + } + if(cnt >= k) return dif[a][b] * exp(c(cnt - 2, k - 2) - c(n, k)); + else return 0; +} +double solve() { + if(n < k || k == 0) return 0; + if(k == 1) return 0; + double res = 0; + for(int i = 1; i <= n; ++i) { + for(int j = i + 1; j <= n; ++j) { + res += calc(i, j); + } + } + return res; +} +int main() { + initPer(); + scanf("%d", &T); + while(T--) { + scanf("%d%d", &n, &k); + init(); + for(int i = 1, a, b; i < n; ++i) { + scanf("%d%d", &a, &b); + add_edge(a, b); + } + for(int i = 1; i <= n; ++i) bfs(i); + for(int i = 1; i <= n; ++i) scanf("%d", &has[i]); + int cnt = 0; + for(int i = 1; i <= n; ++i) tmp[cnt++] = has[i]; + sort(tmp, tmp + cnt); + cnt = unique(tmp, tmp + cnt) - tmp; + for(int i = 1; i <= n; ++i) has[i] = lower_bound(tmp, tmp + cnt, has[i]) - tmp; + for(int i = 1, c = 0; i <= n; ++i) dfs(i, 0, c, i); + printf("%.10f\n", solve()); + } +} diff --git a/HDOJ/4901_autoAC.cpp b/HDOJ/4901_autoAC.cpp new file mode 100644 index 0000000..78e2c87 --- /dev/null +++ b/HDOJ/4901_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +typedef __int64 LL; +#define mod 1000000007 +const int MAXN = 1002; +const int MAXA = 1025; +int dp1[MAXN][MAXA], dp2[MAXN][MAXA], dp3[MAXN][MAXA]; +int a[MAXN]; +int main() +{ + int T, n, i, j, t; + scanf("%d",&T); + while(T--) { + scanf("%d",&n); + for(i = 0; i < n; i++) + scanf("%d",&a[i]); + memset(dp1, 0, sizeof(dp1)); + memset(dp2, 0, sizeof(dp2)); + memset(dp3, 0, sizeof(dp3)); + dp1[0][a[0]] = 1; + for(i = 1; i < n - 1; i++) { + dp1[i][a[i]]++; + for(j = 0; j < MAXA; j++) { + if(dp1[i-1][j]) { + dp1[i][j] += dp1[i-1][j]; + dp1[i][j] %= mod; + t = j ^ a[i]; + dp1[i][t] += dp1[i-1][j]; + dp1[i][t] %= mod; + } + } + } + dp2[n-1][a[n-1]] = 1; + dp3[n-1][a[n-1]] = 1; + for(i = n-2; i > 0; i--) { + dp2[i][a[i]]++; + dp3[i][a[i]]++; + for(j = 0; j < MAXA; j++) { + if(dp2[i+1][j]) { + dp2[i][j] += dp2[i+1][j]; + dp2[i][j] %= mod; + t = j & a[i]; + dp2[i][t] += dp2[i+1][j]; + dp2[i][t] %= mod; + dp3[i][t] += dp2[i+1][j]; + dp3[i][t] %= mod; + } + } + } + int ans = 0; + for(i = 0; i < n - 1; i++) { + for(j = 0; j < MAXA; j++) { + if(dp1[i][j] && dp3[i+1][j]) { + ans += (LL(dp1[i][j]) * dp3[i+1][j] % mod); + ans %= mod; + } + } + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4902_autoAC.cpp b/HDOJ/4902_autoAC.cpp new file mode 100644 index 0000000..2b4a4eb --- /dev/null +++ b/HDOJ/4902_autoAC.cpp @@ -0,0 +1,139 @@ +#include +#include +#include +using namespace std; +#define LL 100005 +#define ll __int64 +#define lson 2*i +#define rson 2*i+1 +#define ls l,mid,2*i +#define rs mid+1,r,2*i+1 +struct node +{ + int l,r; + ll num,maxn; +} a[LL<<2]; +int n,m; +ll gcd(ll a,ll b) +{ + if(!b) return a; + else return gcd(b,a%b); +} +void PushUp(int i) +{ + a[i].num=(a[lson].num==a[rson].num)?a[lson].num:-1; + a[i].maxn=max(a[lson].maxn,a[rson].maxn); +} +void PushDown(int i) +{ + if(a[i].num>-1) + { + a[lson].num = a[rson].num = a[i].num; + a[lson].maxn = a[rson].maxn = a[i].maxn; + } +} +void init(int l,int r,int i) +{ + a[i].l = l; + a[i].r = r; + if(l == r) + scanf("%I64d",&a[i].num); + else + { + int mid = (l+r)>>1; + init(ls); + init(rs); + PushUp(i); + } +} +void change1(int L,int R,ll x,int i) +{ + int l = a[i].l,r = a[i].r; + if(L<=l && r<=R) + { + a[i].num = x; + a[i].maxn = x; + } + else + { + int mid = (l+r)>>1; + PushDown(i); + if(mid>=R) + change1(L,R,x,lson); + else if(mid-1) + { + a[i].num = gcd(a[i].num,x); + a[i].maxn = a[i].num; + } + else + { + PushDown(i); + change2(L,R,x,lson); + change2(L,R,x,rson); + PushUp(i); + } + } + else + { + int mid = (l+r)>>1; + PushDown(i); + if(mid>=R) + change2(L,R,x,lson); + else if(mid-1) + for(int j = l; j<=r; j++) + printf("%I64d ",a[i].num); + else + { + int mid = (l+r)>>1; + print(ls); + print(rs); + } +} +int main() +{ + int t,l,r,cas; + __int64 x; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + init(1,n,1); + scanf("%d",&m); + while(m--) + { + scanf("%d%d%d%I64d",&cas,&l,&r,&x); + if(cas == 1) change1(l,r,x,1); + else change2(l,r,x,1); + } + print(1,n,1); + printf("\n"); + } +} diff --git a/HDOJ/4906_autoAC.cpp b/HDOJ/4906_autoAC.cpp new file mode 100644 index 0000000..63274ed --- /dev/null +++ b/HDOJ/4906_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include +#include +using namespace std; +#define maxn 1<<21 +#define mod 1000000007 +#define ll long long +ll dp[2][maxn]; +void add(ll&a,ll b){ + a+=b; + if(a >= mod) a-=mod; +} +int main(){ + int t,n,l,k,i,j; + scanf("%d",&t); + while(t--){ + scanf("%d%d%d",&n,&k,&l); + int p=0,q=1,f=min(l,k),s=1<<(k-1),s1,s2,s3=(1<16)memset(dp[q],0,sizeof(dp[q])); + else for(j=0;j<=s;j++)dp[q][j]=0; + for(j = 0;j <= s;j++){ + if(dp[p][j] == 0) continue; + dp[q][j] = (dp[q][j]+dp[p][j]*(l-f))%mod; + add(dp[q][j],dp[p][j]); + for(s1=1;s1<=f;s1++){ + s2 = (1<<(s1-1))|j|(j< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define IT __int64 +#define zero(x) fabs(x)eps)-(x<-eps); +} +int main() +{ + int n,m,i,j,q,p,res,k; + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d%d",&n,&m); + for(i=1;i<=Max;i++) + { + s[i]=0; + } + for(i=1;i<=n;i++) + { + scanf("%d",&q); + s[q]=1; + } + k=0; + for(i=1;i<=Max;i++) + { + if(s[i]==0) + t[++k]=i; + } + sort(t+1,t+(k+1)); + while(m--) + { + scanf("%d",&p); + if(s[p]==0) + printf("%d\n",p); + else + { + int left=1; + int right=k; + while(left>1; + if(p +#include +#include +#include +using namespace std; +#define repf(i,a,b) for(int i=(a);i<=(b);i++) +typedef long long ll; +const int N = 4e4+10; +int a[N], rec[N<<1]; +int n, m, pos, cnt; +ll ans; +int main() { + while (~scanf("%d%d", &n, &m)) { + memset(rec, 0, sizeof(rec)); + repf (i, 0, n - 1) { + scanf("%d", &a[i]); + if (a[i] == m) { + pos = i; + } + } + cnt = 0; + for (int i = pos; i >= 0; i--) { + if (a[i] > m) cnt++; + if (a[i] < m) cnt--; + rec[N + cnt]++; + } + cnt = 0; + ans = 0; + for (int i = pos; i < n; i++) { + if (a[i] > m) cnt++; + if (a[i] < m) cnt--; + ans += rec[N - cnt]; + } + cout << ans << endl; + } + return 0; +} diff --git a/HDOJ/4909_autoAC.cpp b/HDOJ/4909_autoAC.cpp new file mode 100644 index 0000000..e6e8320 --- /dev/null +++ b/HDOJ/4909_autoAC.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +using namespace std; +typedef int ll; +const int N = 20005; +int t, n, v, x; +char str[N]; +map has; +int main() { + scanf("%d", &t); + while (t--) { + scanf("%s", str); + v = -1; + n = strlen(str); + for (int i = 0; i < n; i++) { + if (str[i] == '?') { + v = i; + break; + } + } + int ans = 0; + if (v == -1) { + x = 0; + has.clear(); + has[0]++; + for (int i = 0; i < n; i++) { + x ^= (1<<(str[i] - 'a')); + ans += has[x]; + has[x]++; + } + printf("%d\n", ans); + continue; + } + else { + has.clear(); + ans = 0; + x = 0; + has[0]++; + for (int i = 0; i < v; i++) { + x ^= (1<<(str[i] - 'a')); + ans += has[x]; + has[x]++; + } + has.clear(); + x = 0; + has[0]++; + for (int i = v + 1; i < n; i++) { + x ^= (1<<(str[i] - 'a')); + ans += has[x]; + has[x]++; + } + has.clear(); + x = 0; + has[0]++; + for (int i = v + 1; i < n; i++) { + x ^= (1<<(str[i] - 'a')); + has[x]++; + } + x = 0; + if (has.count(x)) + ans += has[x]; + for (int j = 0; j < 26; j++) { + if (has.count(x^(1<= 0; i--) { + x ^= (1<<(str[i] - 'a')); + if (has.count(x)) + ans += has[x]; + for (int j = 0; j < 26; j++) { + if (has.count(x^(1< +#include +#include +#include +#include +#include +using namespace std; +typedef __int64 LL; +const LL NUM=20; +const int maxn=1e6+10; +int prime[maxn],c[maxn],tot; +LL t,f[1000]; +LL mul_mod(LL a,LL b,LL n) +{ + a=a%n; + b=b%n; + LL s=0; + while(b) + { + if(b&1) + s=(s+a)%n; + a=(a<<1)%n; + b=b>>1; + } + return s; +} +LL pow_mod(LL a,LL b,LL n) +{ + a=a%n; + LL s=1; + while(b) + { + if(b&1) + s=mul_mod(s,a,n); + a=mul_mod(a,a,n); + b=b>>1; + } + return s; +} +bool check(LL a,LL n,LL r,LL s) +{ + LL ans,p,i; + ans=pow_mod(a,r,n); + p=ans; + for(i=1;i<=s;i++) + { + ans=mul_mod(ans,ans,n); + if(ans==1&&p!=1&&p!=n-1)return true; + p=ans; + } + if(ans!=1)return true; + return false; +} +bool Miller_Rabin(LL n) +{ + if(n<2)return false; + if(n==2)return true; + if(!(n&1))return false; + LL i,r,s,a; + r=n-1;s=0; + while(!(r&1)){r=r>>1;s++;} + for(i=0;ix)p=y-x; + else p=x-y; + d=gcd(p,n); + if(d!=1&&d!=n)return d; + if(i==k) + { + y=x; + k+=k; + } + } +} +void find(LL n) +{ + if(Miller_Rabin(n)) + { + f[t++]=n; + return; + } + LL p=n; + while(p>=n)p=Pollard_rho(p,rand()%(n-1)+1); + find(p); + find(n/p); +} +void init() +{ + memset(c,false,sizeof(c)); + int i,j; + tot=0; + for(i=2;i<=1e6;i++) + { + if(!c[i])prime[tot++]=i; + for(j=0;j1e6)break; + c[i*prime[j]]=true; + if(i%prime[j]==0)break; + } + } +} +bool judge(LL n) +{ + int i,j,k; + for(i=0;i>n) + { + if(n==-1)break; + if(n==1){cout<<0<=1)ans--; + if(k!=1) + { + if(Miller_Rabin(k))ans++; + else + { + i=(LL)sqrt(k+0.5); + if(i*i==k&&Miller_Rabin(i)||judge(k))ans++; + else ans+=2; + } + } + if(ans<2)cout< +#include +#define N 100005 +__int64 cnt, k; +int a[N],c[N]; +void merge(int a[], int first, int mid, int last, int c[]) +{ + int i = first, j = mid + 1; + int m = mid, n = last; + int k = 0; + while(i <= m || j <= n) + { + if(j > n || (i <= m && a[i] <= a[j])) + c[k++] = a[i++]; + else + { + c[k++] = a[j++]; + cnt += (m - i + 1); + } + } + for(i = 0; i < k; i++) + a[first + i] = c[i]; +} +void merge_sort(int a[], int first, int last, int c[]) +{ + if(first < last) + { + int mid = (first + last) / 2; + merge_sort(a, first, mid, c); + merge_sort(a, mid+1, last, c); + merge(a, first, mid, last, c); + } +} +int main() +{ + int n; + while(~scanf("%d%I64d",&n,&k)) + { + memset(c, 0, sizeof(c)); + cnt = 0; + for(int i = 0; i < n; i++) + scanf("%d", &a[i]); + merge_sort(a, 0, n-1, c); + if(k >= cnt) cnt = 0; + else cnt -= k; + printf("%I64d\n",cnt); + } +} diff --git a/HDOJ/4912_autoAC.cpp b/HDOJ/4912_autoAC.cpp new file mode 100644 index 0000000..17031cc --- /dev/null +++ b/HDOJ/4912_autoAC.cpp @@ -0,0 +1,115 @@ +#include +#include +#include +#include +using namespace std; +const int MAXN=111111; +struct Edge{ + int from,to,next; + Edge(){} + Edge(int f,int t,int n):from(f),to(t),next(n){} +}edge[MAXN*2]; +int head[MAXN],tot,fa[MAXN][20],dep[MAXN],q[MAXN],n,m; +bool vis[MAXN]; +struct Qes{ + int u,v,lca; + Qes(){} + Qes(int _u,int _v,int _fa):u(_u),v(_v),lca(_fa){} + bool operator<(const Qes&rhs)const{ + return dep[lca]>dep[rhs.lca]; + } +}qes[MAXN]; +void init(){ + for(int i=1;i<=n;i++){ + head[i]=-1; + vis[i]=0; + } + tot=0; +} +void add(int f,int t){ + edge[tot]=Edge(f,t,head[f]); + head[f]=tot++; +} +void bfs(int root){ + int tail=0; + q[tail++]=root; + fa[root][0]=root;dep[root]=0; + for(int i=0;i'9')); + if(c==EOF)return false; + while('0'<=c && c<='9'){a=a*10-'0'+c;c=getchar();} + return true; +} +inline void ot(int a){ + if(a>9) + ot(a/10); + putchar(a%10+'0'); +} +int main() +{ + while(get(n)){ + get(m); + init(); + int u,v; + for(int i=1;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 0x3f3f3f3f +#define Inf 0x3FFFFFFFFFFFFFFFLL +#define eps 1e-8 +#define pi acos(-1.0) +using namespace std; +typedef long long ll; +const int maxn=100000+10; +const int mod=1000000000+7; +ll pow_mod(ll x,ll n) +{ + ll res = 1; + while(n) + { + if(n & 1) res = res*x%mod; + n>>=1; + x= x*x%mod; + } + return res; +} +struct Node +{ + int a,b,id; + Node(int a = 0,int b = 0,int id = 0):a(a),b(b),id(id){} +}node[maxn]; +bool cmp1(Node x,Node y) +{ + if(x.a == y.a) return x.id < y.id; + return x.a < y.a; +} +bool cmp2(Node x,Node y) +{ + if(x.b == y.b) return x.a < y.a; + return x.b < y.b; +} +ll sum[maxn<<2],size[maxn<<2]; +void PushUp(int rt) +{ + sum[rt] = sum[rt<<1] + sum[rt<<1|1]*(size[rt<<1] + 1)%mod; + sum[rt] %= mod; + size[rt] = size[rt<<1] + size[rt<<1|1] + size[rt<<1]*size[rt<<1|1]%mod; + size[rt] %= mod; +} +void build(int l,int r,int rt) +{ + sum[rt] = size[rt] = 0; + if(l == r) return ; + int m=(l+r)>>1; + build(l,m,rt<<1); + build(m+1,r,rt<<1|1); +} +void Update(int p,int l,int r,int rt,ll v) +{ + if(l == r) + { + sum[rt] = v; + size[rt] = 1; + return ; + } + int m = (l+r)>>1; + if(m >= p) Update(p,l,m,rt<<1,v); + else Update(p,m+1,r,rt<<1|1,v); + PushUp(rt); +} +ll Query(int L,int R,int l,int r,int rt,ll & sz) +{ + if(l >= L && r <= R) + { + sz = size[rt]; + return sum[rt]; + } + int m = (l+r)>>1; + if(m >= R) return Query(L,R,l,m,rt<<1,sz); + else if(m < L) return Query(L,R,m+1,r,rt<<1|1,sz); + else + { + ll res1,res2,sz1,sz2; + res1 = Query(L,R,l,m,rt<<1,sz1); + res2 = Query(L,R,m+1,r,rt<<1|1,sz2); + sz = (sz1 + sz2 + sz1*sz2%mod)%mod; + return (res1 + res2*(sz1+1))%mod; + } +} +int main() +{ + int n; + while(~scanf("%d",&n)) + { + for(int i = 1;i <= n;++i) + scanf("%d%d",&node[i].a,&node[i].b); + sort(node + 1,node + n +1,cmp2); + for(int i = 1;i <= n;++i) + node[i].id = i; + sort(node + 1,node + n +1,cmp1); + build(1,n,1); + ll ans = 0,lsize,rval,tmp,p2,p3; + int pos; + for(int i = 1;i <= n;++i) + { + pos = node[i].id; + p2 = pow_mod(2,node[i].a); + p3 = pow_mod(3,node[i].b); + Query(1,pos,1,n,1,lsize); + ans += p2*p3%mod*(lsize + 1)%mod; + rval = Query(pos,n,1,n,1,tmp); + ans += p2*rval%mod; + ans += p2*lsize%mod*rval%mod; + ans %= mod; + Update(pos,1,n,1,p3); + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/4914_autoAC.cpp b/HDOJ/4914_autoAC.cpp new file mode 100644 index 0000000..c40f2ef --- /dev/null +++ b/HDOJ/4914_autoAC.cpp @@ -0,0 +1,125 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const double pi = acos(-1.0); +const int maxn = 1 << 18; +const int mo=119; +struct Complex { + double x, y; + Complex (double real = 0, double imag = 0) : x(real), y(imag) {} + double &real() { + return x; + } + double &imag() { + return y; + } + void print() + { + cout<<"real="<>= 1, ~j & s;); + if (i < j) { + swap(P[i], P[j]); + } + } + Complex unit_p0; + for (int d = 0; (1 << d) < n; d++) { + int m = 1 << d, m2 = m * 2; + double p0 = pi / m * oper; + sincos(p0, unit_p0.y, unit_p0.x); + for (int i = 0; i < n; i += m2) { + Complex unit = 1; + for (int j = 0; j < m; j++) { + Complex &P1 = P[i + j + m], &P2 = P[i + j]; + Complex t = unit * P1; + P1 = P2 - t; + P2 = P2 + t; + unit = unit * unit_p0; + } + } + } +} +struct poly{ + int u[50000]; + poly() { + memset(u,0,sizeof(u)); + } + poly operator *(poly &B) { + poly c; + for (int i=0;i=q;i--) + if (c.u[i]) + (c.u[i-p]+=(c.u[i]*a)%mo)%=mo, + (c.u[i-q]+=(c.u[i]*b)%mo)%=mo; + return c; + } + void print() + { + for (int i=0;i>=1) { + if (e&1) sum=sum*b; + b=b*b; + } +} +int main() +{ + for (;cin>>n>>a>>b>>p>>q;) { + a%=mo,b%=mo; + for (int i=1;i<=2*q;i++) + f[i]=(a*func(i-p)+b*func(i-q))%mo; + if (n<=2*q) { + printf("%d\n",f[n]); + continue; + } + for (N=1;N<=q+q+1;N<<=1) ; + poly A,B; + fgm(n-q,A,B); + int ans=0; + for (int i=q-1;i>=0;i--) + ans=(ans+A.u[i]*f[i+q])%mo; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4915_autoAC.cpp b/HDOJ/4915_autoAC.cpp new file mode 100644 index 0000000..aaff28e --- /dev/null +++ b/HDOJ/4915_autoAC.cpp @@ -0,0 +1,87 @@ +#include +#include +#include +using namespace std; +#define mem(a,b) memset(a,0,sizeof(a)) +#define L 1000005 +#define up(i,x,y) for(i = x;i<=y;i++) +#define down(i,x,y) for(i = x;i>=y;i--) +#define bre(x,y) if(x){flag=y;break;} +#define con(x,y) if(x){ans(y);continue;} +char s[L]; +int a[L][2],b[L][2],len,flag; +void ans(int i) +{ + if(i==1) printf("Unique\n"); + else if(i==2) printf("Many\n"); + else printf("None\n"); +} +int main() +{ + int i,j; + while(~scanf("%s",s+1)) + { + len = strlen(s+1); + con((len&1),0) + mem(a,0); + mem(b,0); + flag = 1; + up(i,1,len) + { + if(s[i]=='(') + a[i][0]=a[i-1][0]+1,a[i][1]=a[i-1][1]+1; + else if(s[i]==')') + { + if(!a[i-1][0]) + a[i][0]=1; + else + a[i][0]=a[i-1][0]-1; + a[i][1]=a[i-1][1]-1; + } + else if(s[i]=='?') + { + if(!a[i-1][0]) a[i][0]=1; + else + a[i][0]=a[i-1][0]-1; + a[i][1]=a[i-1][1]+1; + } + bre((a[i][0]>a[i][1]),0) + } + con((!flag),0) + down(i,len,1) + { + if(s[i]==')') + b[i-1][0]=b[i][0]+1,b[i-1][1]=b[i][1]+1; + else if(s[i]=='(') + { + if(!b[i][0]) + b[i-1][0]=1; + else + b[i-1][0]=b[i][0]-1; + b[i-1][1]=b[i][1]-1; + } + else if(s[i]=='?') + { + if(!b[i][0]) b[i-1][0]=1; + else + b[i-1][0]=b[i][0]-1; + b[i-1][1]=b[i][1]+1; + } + bre((b[i][0]>b[i][1]),0) + } + con((!flag),0) + int l,r; + flag = 1; + up(i,1,len) + { + l = max(a[i][0],b[i][0]); + r = min(a[i][1],b[i][1]); + bre((l>r),0) + bre((l +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define INF 0x3f3f3f3f +#define eps 1e-8 +#define pi acos(-1.0) +typedef long long ll; +int fun(){ + char ch;int flag=1,a=0; + while(ch=getchar())if((ch>='0'&&ch<='9')||ch=='-')break; + if(ch=='-')flag=-1;else a=ch-'0'; + while(ch=getchar()){ + if(ch>='0'&&ch<='9')a=10*a+ch-'0'; + else break; + } + return flag*a; +} +const int maxn=1001000; +int head[maxn],tol; +int subtree[maxn]; +int belong[maxn]; +int child[maxn][4]; +int que[maxn]; +int path[maxn]; +int fa[maxn]; +int dep[maxn]; +struct Edge{ + int next,to; +}edge[2*maxn]; +void addedge(int u,int v){ + edge[tol].to=v; + edge[tol].next=head[u]; + head[u]=tol++; +} +int main() +{ + int n,m; + while(~scanf("%d%d",&n,&m)){ + memset(head,-1,sizeof(head));tol=0; + for(int i=1;i=0;i--){ + int u=que[i]; + subtree[u]=min(u,child[u][0]); + int p=fa[u]; + if(p==-1)continue; + child[p][3]=subtree[u]; + sort(child[p],child[p]+4); + } + front=0,rear=0; + path[1]=INF; + belong[1]=-1; + for(int i=head[1];i!=-1;i=edge[i].next){ + int u=edge[i].to; + path[u]=INF; + belong[u]=subtree[u]; + que[rear++]=u; + } + while(front!=rear){ + int u=que[front++]; + for(int i=head[u];i!=-1;i=edge[i].next){ + int v=edge[i].to; + if(v==fa[u])continue; + path[v]=min(path[u],child[u][subtree[v]==child[u][0]]); + belong[v]=belong[u]; + que[rear++]=v; + } + path[u]=min(path[u],child[u][0]); + } + int last=0; + while(m--){ + int u,v; + u=fun();v=fun(); + u^=last;v^=last; + if(u>v)swap(u,v); + if(u!=1&&belong[u]==belong[v])last=1; + else{ + int i=0; + while(child[1][i]==belong[u]||child[1][i]==belong[v])i++; + last=u==1?path[v]:min(path[u],path[v]); + last=min(last,child[1][i]); + } + printf("%d\n",last); + } + } + return 0; +} diff --git a/HDOJ/4917_autoAC.cpp b/HDOJ/4917_autoAC.cpp new file mode 100644 index 0000000..c892dc0 --- /dev/null +++ b/HDOJ/4917_autoAC.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#define ll __int64 +using namespace std ; +vector vec[44] ; +const int mod = 1000000007 ; +int dp[1<<21] ; +int fa[44] , sz[44] , vis[44] ; +int to[44] , id[44] , du[44] ; +int c[44][44] ; +void init () { + c[0][0] = 1 ; + for ( int i = 1 ; i < 44 ; i ++ ) { + c[i][0] = 1 ; + for ( int j = 1 ; j <= i ; j ++ ) + c[i][j] = ( c[i-1][j] + c[i-1][j-1] ) % mod ; + } +} +int find ( int a ) { + return fa[a] == a ? a : fa[a] = find ( fa[a] ) ; +} +struct Point { + int id , st ; + Point () {} + Point (int a , int b):id(a),st(b) {} +} ; +int gao ( int s , int n , int& re) { + int tot = 0 ; + queue Q ; + for ( int i = 1 ; i <= n ; i ++ ) { + if ( find (i) == s && du[i] == 0 ) { + to[tot++] = 0 ; + Q.push ( Point(i,1< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 0x3f3f3f3f +#define Inf 0x3FFFFFFFFFFFFFFFLL +#define eps 1e-9 +#define pi acos(-1.0) +using namespace std; +typedef long long ll; +const int maxn = 100000 + 10; +const int M = 40; +int pool[maxn*M]; +int pool_size; +struct BIT +{ + int *C,n; + void Init(int n) + { + this -> n = n; + C = pool + pool_size; + for(int i = 0;i < n;++i) + C[i] = 0; + pool_size += n; + } + void add(int x,int v) + { + for(;x < n; x += x & -x) + C[x] += v; + } + int sum(int x) + { + if(x >= n) x = n - 1; + int res = 0; + for(;x > 0; x -= x & -x) + res += C[x]; + return res; + } +}tree[maxn<<1]; +struct Node +{ + int root,subtree,dis; + Node(int root = 0,int subtree = 0,int dis = 0):root(root),subtree(subtree),dis(dis){} +}; +vectorvt[maxn]; +struct Edge +{ + int v,next; + Edge(int v = 0,int next = 0):v(v),next(next){} +}edges[maxn<<1]; +int head[maxn],w[maxn],id[maxn<<1],cnt,nEdge; +int q[maxn],dp[maxn],fa[maxn],flag[maxn],d[maxn]; +void AddEdges(int u,int v) +{ + edges[++nEdge] = Edge(v,head[u]); + head[u] = nEdge; + edges[++nEdge] = Edge(u,head[v]); + head[v] = nEdge; +} +void Init(int n) +{ + pool_size = cnt = 0; + memset(head,0xff,sizeof(head)); + memset(flag,0,sizeof(flag)); + nEdge = -1; + for(int i = 1;i <= n;++i) + vt[i].clear(); +} +int getroot(int x,int & tot) +{ + int tail = 0,u,v; + q[tail++] = x; + fa[x] = -1; + for(int i = 0;i < tail;++i) + { + u = q[i]; + for(int k = head[u];k != -1;k = edges[k].next) + { + v = edges[k].v; + if(v != fa[u] && !flag[v]) + { + fa[v] = u; + q[tail++] = v; + } + } + } + int minv = inf,root = x,mx; + for(int i = tail - 1;i >= 0;--i) + { + u = q[i]; + dp[u] = 1; + mx = 0; + for(int k = head[u];k != -1;k = edges[k].next) + { + v = edges[k].v; + if(v != fa[u] && !flag[v]) + { + mx = max(mx,dp[v]); + dp[u] += dp[v]; + } + } + mx = max(mx,tail - dp[u]); + if(mx < minv) minv = mx,root = u; + } + tot = tail; + return root; +} +void cal(int x,int pa,int subtree) +{ + int tail = 0,u,v; + q[tail++] = x; + d[x] = 1; + fa[x] = pa; + for(int i = 0;i < tail;++i) + { + u = q[i]; + vt[u].push_back(Node(id[pa],subtree,d[u])); + tree[id[pa]].add(d[u]+1,w[u]); + tree[subtree].add(d[u],w[u]); + for(int k = head[u];k != -1;k = edges[k].next) + { + v = edges[k].v; + if(v != fa[u] && !flag[v]) + { + d[v] = d[u] + 1; + fa[v] = u; + q[tail++] = v; + } + } + } +} +void solve(int x) +{ + int num; + int rt = getroot(x,num); + flag[rt] = 1; + id[rt] = ++cnt; + vt[rt].push_back(Node(cnt,-1,0)); + tree[cnt].Init(num + 2); + tree[cnt].add(1,w[rt]); + for(int k = head[rt];k != -1;k = edges[k].next) + if(!flag[edges[k].v]) + { + ++cnt; + tree[cnt].Init(dp[edges[k].v] + 2); + cal(edges[k].v,rt,cnt); + } + for(int k = head[rt];k != -1;k = edges[k].next) + if(!flag[edges[k].v]) solve(edges[k].v); +} +char s[20]; +int main() +{ + int n,q; + while(~scanf("%d%d",&n,&q)) + { + Init(n); + for(int i = 1;i <= n;++i) + scanf("%d",&w[i]); + int u,v; + for(int i = 1;i < n;++i) + { + scanf("%d%d",&u,&v); + AddEdges(u,v); + } + solve(1); + Node node; + while(q--) + { + scanf("%s%d%d",s,&u,&v); + if(s[0] == '!') + { + int d = v - w[u]; + for(int i = 0;i < (int)vt[u].size();++i) + { + node = vt[u][i]; + tree[node.root].add(node.dis + 1,d); + if(node.subtree != -1) + tree[node.subtree].add(node.dis , d); + } + w[u] += d; + } + else + { + int d = v,ans = 0; + for(int i = 0;i < (int)vt[u].size();++i) + { + node = vt[u][i]; + ans += tree[node.root].sum(d - node.dis + 1); + if(node.subtree != -1) + ans -= tree[node.subtree].sum(d - node.dis); + } + printf("%d\n",ans); + } + } + } + return 0; +} diff --git a/HDOJ/4920_autoAC.cpp b/HDOJ/4920_autoAC.cpp new file mode 100644 index 0000000..046d2e0 --- /dev/null +++ b/HDOJ/4920_autoAC.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +using namespace std; +int a[805][805],b[805][805],c[805][805]; +int main() +{ + int n,i,j,k; + while(~scanf("%d",&n)) + { + for(i = 0; i +#include +#include +#include +using namespace std ; +int son[11111] ; +int chain[10][1111] , a[11111] ; +int vis[11111] , du[11111] , len[11] ; +double dfs ( int u , int step , int c ) { + chain[c][step] = a[u] ; + if ( son[u] == -1 ) return step + 2 ; + return dfs ( son[u] , step + 1 , c ) ; +} +int main () { + int n , m ; + int T ; + scanf ( "%d" , &T ) ; + while ( T -- ) { + scanf ( "%d%d" , &n , &m ) ; + memset ( chain , 0 , sizeof ( chain ) ) ; + memset ( du , 0 , sizeof ( du ) ) ; + memset ( son , -1 , sizeof ( son ) ) ; + for ( int i = 0 ; i < n ; i ++ ) + scanf ( "%d" , &a[i] ) ; + for ( int i = 1 ; i <= m ; i ++ ) { + int a , b ; + scanf ( "%d%d" , &a , &b ) ; + son[a] = b ; + du[b] ++ ; + } + double sum = 1 , ans = 0 ; + int tot = 0 ; + for ( int i = 0 ; i < n ; i ++ ) { + if ( du[i] == 0 ) { + len[tot] = dfs ( i , 0 , tot ) ; + sum *= len[tot] ; + len[tot] -- ; + tot ++ ; + } + } + sum -= 1 ; + for ( int i = 0 ; i < 1000 ; i ++ ) { + for ( int j = 0 ; j < 1 << tot ; j ++ ) { + int flag = 0 ; + double add = 0 , p = 1 , x = 0 , cnt = 0 ; + for ( int k = 0 ; k < tot ; k ++ ) { + if ( chain[k][i] ) cnt ++ ; + if ( j & (1<1?(add*x/cnt):0) ) * p ; + ans += fuck ; + } + } + printf ( "%.3f\n" , ans / sum ) ; + } + return 0 ; +} diff --git a/HDOJ/4923_autoAC.cpp b/HDOJ/4923_autoAC.cpp new file mode 100644 index 0000000..1a5da65 --- /dev/null +++ b/HDOJ/4923_autoAC.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=1e5+10; +const double eps=1e-8; +const int INF=2e9; +struct node{ + int id,num0,num1; + double rate; +}e[maxn],f,g; +int t,a[maxn]; +stackmm; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + int i,j,k,n,p,q; + double num,ans=0; + t=0; + scanf("%d",&n); + int l=0,r=n-1; + for(i=0;ir){printf("0.000000\n");continue;} + for(i=l;i<=r;) + { + j=k=0; + while(a[i]==1){i++;j++;} + while(a[i]==0){i++;k++;} + e[t].id=t;e[t].num1=j;e[t].num0=k;e[t].rate=1.0*j/(j+k); + t++; + } + while(!mm.empty())mm.pop(); + for(i=0;ig.rate) + { + g.num1+=f.num1; + g.num0+=f.num0; + g.rate=1.0*g.num1/(g.num0+g.num1); + mm.pop(); + } + else + { + mm.push(g); + break; + } + if(mm.empty()) + { + mm.push(g); + break; + } + } + } + } + } + while(!mm.empty()) + { + f=mm.top(); + mm.pop(); + ans+=f.rate*f.rate*f.num0+(1-f.rate)*(1-f.rate)*f.num1; + } + printf("%.6f\n",ans); + } + return 0; +} diff --git a/HDOJ/4924_autoAC.cpp b/HDOJ/4924_autoAC.cpp new file mode 100644 index 0000000..3da7a61 --- /dev/null +++ b/HDOJ/4924_autoAC.cpp @@ -0,0 +1,144 @@ +#include +#define INF 99999999 +#define max(A,B)(A>B?A:B) +struct S{ +int c[4],p[4],mx; +bool flag[4]; +}node[20]; +int n,hash[100],add[20][20],a,b,c,ansc,ansp,df,mf,st,gk,attach,dpc[13][3][13][13],dpp[13][3][13][13],sel[13]; +void dfs(int now,int cnt) +{ + if(cnt==11) + { + int i,j,k,l,mx; + attach=0; + for(i=0;i<11;i++) for(j=0;j<11;j++) attach+=add[sel[i]][sel[j]]; + mx=0; + for(i=0;i<11;i++) mx+=node[sel[i]].mx; + if(mx+attach=n || cnt+n-now<11) return; + sel[cnt]=now; + dfs(now+1,cnt+1); + dfs(now+1,cnt); +} +int main() +{ + int T,i,j,t,id,val; + char s[5]; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + for(i=0;i-INF) printf("%d %d\n",ansc,ansp); + else printf("Poor Manager!\n"); + } +} diff --git a/HDOJ/4925_autoAC.cpp b/HDOJ/4925_autoAC.cpp new file mode 100644 index 0000000..45178f5 --- /dev/null +++ b/HDOJ/4925_autoAC.cpp @@ -0,0 +1,57 @@ +#include +#include +#include +#include +using namespace std; +const int maxn = 110; +int map[maxn][maxn]; +int n, m; +int cal(int i, int j) { + int ans = 1; + if (map[i][j+1] == 0) + ans <<= 1; + if (map[i+1][j] == 0) + ans <<= 1; + if (map[i-1][j] == 0) + ans <<= 1; + if (map[i][j-1] == 0) + ans <<= 1; + return ans; +} +int main() { + int t; + scanf("%d", &t); + while (t--) { + scanf("%d%d", &n, &m); + memset(map, -1, sizeof(map)); + int flag = 0; + for (int i = 1; i <= m; i++) { + map[1][i] = flag; + flag = !flag; + } + for (int i = 2; i <= n; i++) + for (int j = 1; j <= m; j++) + map[i][j] = !map[i-1][j]; + int ans = 0; + for (int i = 1; i <= n; i++) + for (int j = 1; j <= m; j++) + if (map[i][j]) + ans += cal(i, j); + memset(map, -1, sizeof(map)); + flag = 1; + for (int i = 1; i <= m; i++) { + map[1][i] = flag; + flag = !flag; + } + for (int i = 2; i <= n; i++) + for (int j = 1; j <= m; j++) + map[i][j] = !map[i-1][j]; + int tmp = 0; + for (int i = 1; i <= n; i++) + for (int j = 1; j <= m; j++) + if (map[i][j]) + tmp += cal(i, j); + printf("%d\n", max(ans, tmp)); + } + return 0; +} diff --git a/HDOJ/4927_autoAC.cpp b/HDOJ/4927_autoAC.cpp new file mode 100644 index 0000000..dfecc6b --- /dev/null +++ b/HDOJ/4927_autoAC.cpp @@ -0,0 +1,244 @@ +#include +#include +using namespace std; +#define MAXN 9999 +#define MAXSIZE 10 +#define DLEN 4 +class BigInt +{ +private: + int a[500]; + int len; +public: + BigInt() {len = 1; memset(a, 0, sizeof(a));} + BigInt(const int); + BigInt(const char *); + BigInt(const BigInt &); + BigInt &operator = (const BigInt &); + BigInt operator + (const BigInt &) const; + BigInt operator - (const BigInt &) const; + BigInt operator * (const BigInt &) const; + BigInt operator / (const int &) const; + bool operator > (const BigInt &T) const; + bool operator < (const BigInt &T) const; + bool operator == (const BigInt &T) const; + bool operator > (const int &t) const; + bool operator < (const int &t) const; + bool operator == (const int &t) const; + void print(); +}; +bool BigInt::operator == (const BigInt &T) const { + return !(*this > T) && !(T > *this); +} +bool BigInt::operator == (const int &t) const { + BigInt T = BigInt(t); + return *this == T; +} +bool BigInt::operator < (const BigInt &T) const { + return T > *this; +} +bool BigInt::operator < (const int &t) const { + return BigInt(t) > *this; +} +BigInt::BigInt(const int b) { + int c, d = b; + len = 0; + memset(a, 0, sizeof(a)); + while(d > MAXN) { + c = d - (d / (MAXN + 1)) * (MAXN + 1); + d = d / (MAXN + 1); + a[len++] = c; + } + a[len++] = d; +} +BigInt::BigInt(const char *s) { + int t, k, index, l, i; + memset(a, 0, sizeof(a)); + l = strlen(s); + len = l / DLEN; + if(l % DLEN) + len++; + index = 0; + for(i = l - 1; i >= 0; i -= DLEN) + { + t = 0; + k = i - DLEN + 1; + if(k < 0) + k = 0; + for(int j = k;j <= i; j++) + t = t * 10 + s[j] - '0'; + a[index++] = t; + } +} +BigInt::BigInt(const BigInt &T) : len(T.len) +{ + int i; + memset(a, 0, sizeof(a)); + for(i = 0; i < len; i++) + a[i] = T.a[i]; +} +BigInt & BigInt::operator = (const BigInt &n) +{ + int i; + len = n.len; + memset(a, 0, sizeof(a)); + for(i = 0; i < len; i++) + a[i] = n.a[i]; + return *this; +} +BigInt BigInt::operator + (const BigInt &T) const{ + BigInt t(*this); + int i, big; + big = T.len > len ? T.len : len; + for(int i = 0; i < big; i++) + { + t.a[i] += T.a[i]; + if(t.a[i] > MAXN) + { + t.a[i+1]++; + t.a[i] -= MAXN + 1; + } + } + if(t.a[big] != 0) + t.len = big + 1; + else + t.len = big; + return t; +} +BigInt BigInt::operator - (const BigInt &T) const { + int i, j, big; + bool flag; + BigInt t1, t2; + if(*this > T) + { + t1 = *this; + t2 = T; + flag = 0; + } + else + { + t1 = T; + t2 = *this; + flag = 1; + } + big = t1.len; + for(i = 0; i < big; i++) + { + if(t1.a[i] < t2.a[i]) + { + j = i + 1; + while(t1.a[j] == 0) + j++; + t1.a[j--]--; + while(j > i) + t1.a[j--] += MAXN; + t1.a[i] += MAXN + 1 - t2.a[i]; + } + else + t1.a[i] -= t2.a[i]; + } + t1.len = big; + while(t1.a[t1.len - 1] == 0 && t1.len > 1) + { + t1.len--; + big--; + } + if(flag) + t1.a[big-1] = 0 - t1.a[big-1]; + return t1; +} +BigInt BigInt::operator * (const BigInt &T) const { + BigInt ret; + int i, j, up; + int tmp, temp; + for(i = 0; i < len; i++) + { + up = 0; + for(j = 0; j < T.len; j++) + { + temp = a[i] * T.a[j] + ret.a[i+j] + up; + if(temp > MAXN) + { + tmp = temp - temp / (MAXN + 1) * (MAXN + 1); + up = temp / (MAXN + 1); + ret.a[i + j] = tmp; + } + else + { + up = 0; + ret.a[i + j] = temp; + } + } + if(up != 0) + ret.a[i + j] = up; + } + ret.len = i + j; + while(ret.a[ret.len - 1] == 0 && ret.len > 1) + ret.len--; + return ret; +} +BigInt BigInt::operator / (const int &b) const { + BigInt ret; + int i, down = 0; + for(i = len - 1; i >= 0; i--) + { + ret.a[i] = (a[i] + down * (MAXN + 1)) / b; + down = a[i] + down * (MAXN + 1) - ret.a[i] * b; + } + ret.len = len; + while(ret.a[ret.len - 1] == 0 && ret.len > 1) + ret.len--; + return ret; +} +bool BigInt::operator > (const BigInt &T) const { + int ln; + if(len > T.len) + return true; + else if(len == T.len) + { + ln = len - 1; + while(a[ln] == T.a[ln] && ln >= 0) + ln--; + if(ln >= 0 && a[ln] > T.a[ln]) + return true; + else + return false; + } + else + return false; +} +bool BigInt::operator > (const int &t) const { + BigInt b(t); + return *this > b; +} +void BigInt::print() +{ + printf("%d",a[len-1]); + for(int i = len - 2; i >= 0; i--) + printf("%04d", a[i]); + printf("\n"); +} +int main() +{ + int n, T, i, j, a[3005]; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + for(i = 1; i <= n; i++) + scanf("%d",&a[i]); + BigInt positive(0), negative(0), C(1), tmp; + for(i = 0; i <= n - 1; i++) + { + if(i > 0) C = (C * (BigInt)(n - i)) / i; + tmp = C * (BigInt)(a[n-i]); + if(i&1) + negative = negative + tmp; + else + positive = positive + tmp; + } + BigInt ans = positive - negative; + ans.print(); + } + return 0; +} diff --git a/HDOJ/4928_autoAC.cpp b/HDOJ/4928_autoAC.cpp new file mode 100644 index 0000000..05308b0 --- /dev/null +++ b/HDOJ/4928_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +using namespace std; +typedef long long LL; +const int SIZEN=100005; +LL a[SIZEN]; +LL t_a[SIZEN]; +int val_h,val_t; +int check(int cnt){ + int flag=1; + for(int i=0;ia[i+1]) flag=0; + if(flag) return 1; + flag=1; + for(int i=0;i=0) {cnt--;val_t++;} + } +} +int main() +{ + int _; + scanf("%d",&_); + while(_--) solve(); + return 0; +} diff --git a/HDOJ/4929_autoAC.cpp b/HDOJ/4929_autoAC.cpp new file mode 100644 index 0000000..54705c1 --- /dev/null +++ b/HDOJ/4929_autoAC.cpp @@ -0,0 +1,146 @@ +#pragma comment(linker, "/STACK:1024000000,1024000000") +#include +#include +#include +#include +using namespace std ; +void get_num ( int& n ) { + n = 0 ; + char c ; + while ( c = getchar () ) { + if ( c >= '0' && c <= '9' ) break ; + } + n = c - '0' ; + while ( c = getchar () ) { + if ( c < '0' || c > '9' ) break ; + n = n * 10 + c -'0' ; + } +} +const int maxn = 50005 ; +const int mod = 10007 ; +short dp[2][33][33][maxn] ; +int c[33] , d[33] ; +char s[maxn] , s1[33] ; +vector vec[maxn] ; +int p[20][maxn] , fa[maxn] , deep[maxn] ; +struct LCA { + void dfs ( int u ) { + if ( u == 1 ) fa[u] = 0 ; + p[0][u] = fa[u] ; + deep[u] = deep[fa[u]] + 1 ; + for ( int i = 1 ; i < 20 ; i ++ ) p[i][u] = p[i-1][p[i-1][u]] ; + int sz = vec[u].size () ; + for ( int i = 0 ; i < sz ; i ++ ) { + int v = vec[u][i] ; + if ( v == fa[u] ) continue ; + fa[v] = u ; + dfs ( v ) ; + } + } + int father_k ( int u , int k ) { + for ( int i = 0 ; i < 20 ; i ++ ) + if ( k & ( 1 << i ) ) + u = p[i][u] ; + return u ; + } + int query ( int a , int b ) { + if ( deep[a] > deep[b] ) swap ( a , b ) ; + b = father_k ( b , deep[b] - deep[a] ) ; + if ( a == b ) return a ; + for ( int i = 19 ; i >= 0 ; i -- ) { + if ( fa[a] == fa[b] ) break ; + if ( p[i][a] != p[i][b] ) { + a = p[i][a] ; + b = p[i][b] ; + } + } + return fa[a] ; + } +} lca ; +int l ; +void dfs ( int u , int x , int c ) { + for ( int i = x ; i <= l ; i ++ ) { + dp[c][x][i][u] += dp[c][x][i][fa[u]] ; + if ( dp[c][x][i][u] >= mod ) dp[c][x][i][u] -= mod ; + if ( s[u] == s1[i] ) + dp[c][x][i][u] += dp[c][x][i-1][fa[u]] ; + if ( dp[c][x][i][u] >= mod ) dp[c][x][i][u] -= mod ; + } + int sz = vec[u].size () ; + for ( int i = 0 ; i < sz ; i ++ ) { + int v = vec[u][i] ; + if ( v == fa[u] ) continue ; + dfs ( v , x , c ) ; + } +} +void DP ( int n , int c ) { + for ( int i = 0 ; i <= l + 1 ; i ++ ) { + for ( int j = 0 ; j <= n ; j ++ ) { + for ( int k = 0 ; k <= i ; k ++ ) + dp[c][k][i][j] = 0 ; + if (i) dp[c][i][i-1][j] = 1 ; + } + } + for ( int i = 1 ; i <= l ; i ++ ) + dfs ( 1 , i , c ) ; +} +int main () { + int T , n , q ; + scanf ( "%d" , &T ) ; + while ( T -- ) { + scanf ( "%d%d" , &n , &q ) ; + for ( int i = 1 ; i <= n ; i ++ ) vec[i].clear () ; + for ( int i = 1 ; i < n ; i ++ ) { + int a , b ; + get_num (a) ; + get_num (b) ; + vec[a].push_back (b) ; + vec[b].push_back (a) ; + } + scanf ( "%s" , s + 1 ) ; + scanf ( "%s" , s1 + 1 ) ; + l = strlen ( s1 + 1 ) ; + lca.dfs ( 1 ) ; + reverse ( s1 + 1 , s1 + l + 1 ) ; + DP ( n , 0 ) ; + reverse ( s1 + 1 , s1 + l + 1 ) ; + DP ( n , 1 ) ; + while ( q -- ) { + int a , b , x , y ; + get_num (a) ; + get_num (b) ; + if ( a == b ) { + if ( l == 1 && s[a] == s1[1] ) puts ( "1" ) ; + else puts ( "0" ) ; + continue ; + } + int w = lca.query ( a , b ) ; + int ans = 0 ; + memset ( c , 0 , sizeof ( c ) ) ; + memset ( d , 0 , sizeof ( d ) ) ; + for ( int i = 0 ; i <= l ; i ++ ) { + c[i] = dp[0][l-i+1][l][a] ; + d[i] = dp[1][l-i+1][l][b] ; + for ( int j = 0 ; j < i ; j ++ ) { + c[i] -= (c[j] * dp[0][l-i+1][l-j][w] % mod) ; + d[i] -= (d[j] * dp[1][l-i+1][l-j][w] % mod) ; + c[i] += mod ; + if ( c[i] >= mod ) c[i] -= mod ; + d[i] += mod ; + if ( d[i] >= mod ) d[i] -= mod ; + } + } + for ( int i = 0 ; i <= l ; i ++ ) { + ans += c[i] * d[l-i] % mod ; + if ( ans >= mod ) ans -= mod ; + } + for ( int i = 0 ; i < l ; i ++ ) { + if ( s[w] == s1[i+1] ) { + ans += c[i] * d[l-i-1] % mod ; + if ( ans >= mod ) ans -= mod ; + } + } + printf ( "%d\n" , ans ) ; + } + } +} diff --git a/HDOJ/4930_autoAC.cpp b/HDOJ/4930_autoAC.cpp new file mode 100644 index 0000000..5be9a65 --- /dev/null +++ b/HDOJ/4930_autoAC.cpp @@ -0,0 +1,149 @@ +#include +#include +#include +using namespace std; +#define sss1 {ans(1);continue;} +#define sss0 {ans(0);continue;} +char s1[20],s2[20]; +int p1[16],p2[16],len1,len2; +int a[8],b[8],kk[10] = {0,0,0,14,13,12,11,10,9,8}; +int check(char c) +{ + if(c == 'Y') + return 0; + if(c == 'X') + return 1; + if(c == '2') + return 2; + if(c == 'A') + return 3; + if(c == 'K') + return 4; + if(c == 'Q') + return 5; + if(c == 'J') + return 6; + if(c == 'T') + return 7; + for(int i = '9';i>='3';i--) + { + if(c == i) + return kk[i-'0']; + } +} +void ans(int i) +{ + if(i==1) + printf("Yes\n"); + else + printf("No\n"); +} +int Solo() +{ + int i; + for(i = 0; i<15; i++) + { + if(p1[i]) + return 1; + if(p2[i]) + return 0; + } +} +int Pair() +{ + int i; + for(i = 2; i<15; i++) + { + if(p1[i]>=2) + return 1; + if(p2[i]>=2) + return 0; + } +} +int Trio() +{ + int i; + for(i = 2; i<15; i++) + { + if(p1[i]>=3) + return 1; + if(p2[i]>=3) + return 0; + } +} +int Bomb() +{ + int i; + for(i = 2; i<15; i++) + { + if(p1[i]>=4) + return 1; + if(p2[i]>=4) + return 0; + } +} +int main() +{ + int t,i,j; + scanf("%d",&t); + while(t--) + { + scanf("%s%s",s1,s2); + len1 = strlen(s1); + len2 = strlen(s2); + memset(p1,0,sizeof(p1)); + memset(p2,0,sizeof(p2)); + memset(a,0,sizeof(a)); + memset(b,0,sizeof(b)); + for(i = 0; i= 4 && len2<4) + sss1 + else if(a[2] && (!b[2]||len2<5)) + sss1 + } + } + if(a[2] && !b[2] && !b[3]) + sss1 + if(a[2] && (b[2]||b[3])) + { + if(Pair()) + sss1 + } + if(Solo()) + sss1 + sss0 + } + return 0; +} diff --git a/HDOJ/4931_autoAC.cpp b/HDOJ/4931_autoAC.cpp new file mode 100644 index 0000000..cc46681 --- /dev/null +++ b/HDOJ/4931_autoAC.cpp @@ -0,0 +1,21 @@ +#include +#include +#include +using namespace std; +int a[20]; +int main() +{ + int T; + scanf("%d",&T); + for(int i=1;i<=T;i++) + { + for(int i=1;i<=6;i++) + scanf("%d",&a[i]); + sort(a+1,a+7); + if(a[6]+a[5]>a[4]+a[3]+a[2]) + printf("Grandpa Shawn is the Winner!\n"); + else + printf("What a sad story!\n"); + } + return 0; +} diff --git a/HDOJ/4932_autoAC.cpp b/HDOJ/4932_autoAC.cpp new file mode 100644 index 0000000..5868d3d --- /dev/null +++ b/HDOJ/4932_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=55; +const int inf=1<<29; +const double eps=1e-6; +int n; +double a[maxn],dp[maxn][2]; +vector set; +bool check(double val) +{ + bool last=false; + for(int i=1;i=val) + { + last=false; + continue; + } + if(last&&fabs(a[i]-a[i-1]-val)<=eps) + { + last=false; + continue; + } + if(last&&(a[i]-a[i-1])/2>=val) + { + last=false; + continue; + } + if(a[i+1]-a[i]>=val) + { + last=true; + continue; + } + return false; + } + return true; +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + memset(dp,0,sizeof(dp)); + scanf("%d",&n); + for(int i=0;i=0;i--) + if(check(set[i])) + { + ans=set[i]; + break; + } + printf("%.3f\n",ans); + } + return 0; +} diff --git a/HDOJ/4933_autoAC.cpp b/HDOJ/4933_autoAC.cpp new file mode 100644 index 0000000..a159276 --- /dev/null +++ b/HDOJ/4933_autoAC.cpp @@ -0,0 +1,239 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 10050 +#define LL __int64 +int dp[2][10][110]; +int num[110]; +void dos(char str[],int leap) +{ + int n=strlen(str); + for(int i=0;inum[i])continue; + if(j=10) + { + int y=0; + while(x) + { + y+=x%10; + x=x/10; + } + x=y; + } + return x; +} +void out(int f,int len) +{ + int aa=0; + int y=0; + for(int i=len;i>=0;i--) + { + aa=aa*10+ans[i]; + aa=aa%f; + y=y*10-ans[i]; + y=y%f; + } + if(fuhao==0) + { + y=-y; + cout<<(y%f+f)%f< +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define LL __int64 +const int maxn=1e5+10; +int main() +{ + int T; + scanf("%d",&T); + int tt=0; + while(T--) + { + LL n,t,ans=0; + LL i,j,k; + LL a,b,c,d,x; + scanf("%I64d",&n); + if(n>=3&&n<=6){printf("Case #%d: -1\n",++tt);continue;} + for(i=3;i<=6;i++) + { + for(j=3;j<=6;j++) + { + if((n-i)%j==0&&(n-i)/j>max(i,j)) + { + //printf(" %I64d+%I64d*%I64d\n",i,j,(n-i)/j); + ans++; + } + } + } + for(i=3;i<=6;i++) + { + for(j=3;j<=6;j++) + { + for(k=3;k<=6;k++) + { + a=i;b=j;c=k-n; + d=(LL)sqrt(b*b-a*c*4+0.5); + if(d*d!=b*b-a*c*4)continue; + if((d-b)%(a*2))continue; + x=(d-b)/(a*2); + if(x>max(max(i,j),k)) + { + ans++; + } + } + } + } + for(i=2;i*i*i<=n;i++) + { + t=n; + while(t) + { + if(t%i<3||t%i>6)break; + t=t/i; + } + if(!t) + { + ans++; + } + } + printf("Case #%d: %I64d\n",++tt,ans); + } + return 0; +} diff --git a/HDOJ/4938_autoAC.cpp b/HDOJ/4938_autoAC.cpp new file mode 100644 index 0000000..8f1cff0 --- /dev/null +++ b/HDOJ/4938_autoAC.cpp @@ -0,0 +1,137 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define REP(i,n) for(int i=0;i=b;--i) +#define MP make_pair +#define LL long long +#define X first +#define Y second +#define MAXN 100050 +#define eps 1e-8 +using namespace std; +struct Point { + double x, y; +} p1[MAXN], p2[MAXN]; +struct Line { + Point p, q; +}; +Point Intersect(Line u, Line v) + { + Point ret = u.p; + double t = ((u.p.x - v.p.x) * (v.p.y - v.q.y) + - (u.p.y - v.p.y) * (v.p.x - v.q.x)) + / ((u.p.x - u.q.x) * (v.p.y - v.q.y) + - (u.p.y - u.q.y) * (v.p.x - v.q.x)); + ret.x += (u.q.x - u.p.x) * t; + ret.y += (u.q.y - u.p.y) * t; + return ret; +} +struct node { + double x, w; + int id, type; +} s[MAXN]; +bool cmp1(node a, node b) { + return a.x < b.x - eps || (fabs(a.x - b.x) < eps && a.type < b.type); +} +bool cmp2(node a, node b) { + return a.x < b.x - eps || (fabs(a.x - b.x) < eps && a.type > b.type); +} +int d[MAXN]; +int ans[MAXN]; +int main() { + int tt, ri = 0, n; + scanf("%d", &tt); + while (tt--) { + Line L; + L.p.x = L.p.y = L.q.y = 0; + L.q.x = 100; + double v1, v2; + scanf("%d%lf%lf", &n, &v1, &v2); + double si = v1 / sqrt(v1 * v1 + v2 * v2); + REP(i,n) + { + double a, t, p, w; + scanf("%lf%lf%lf%lf", &a, &t, &p, &w); + Line L1; + if (a == 1) { + L1.p.x = 1.0*p; + L1.p.y = -1.0*t * v1; + L1.q.x = 1.0*p - v2; + L1.q.y = -1.0*t * v1 + v1; + } else { + L1.p.x = -1.0*t * v2; + L1.p.y = 1.0*p; + L1.q.x = -1.0*t * v2 - v2; + L1.q.y = 1.0*p + v1; + } + Point e = Intersect(L, L1); + s[i].x = e.x; + s[i].type = a; + if(a==1) + s[i].w = w ; + else + s[i].w=w*1.0*v2/v1; + s[i].id = i; + } + sort(s, s + n, cmp1); + d[n] = 0; + for (int i = n - 1; i >= 0; --i) { + d[i] = d[i + 1]; + if (s[i].type == 2) { + d[i]++; + continue; + } + int l, r; + l = i; + r = n - 1; + while (r - l > 1) { + int mid = (l + r) >> 1; + if (s[mid].x - s[i].x > s[i].w + eps) + r = mid; + else + l = mid; + } + if (s[r].x - s[i].x < s[i].w + eps) + ans[s[i].id] = d[i]-d[r+1]; + else + ans[s[i].id] = d[i] - d[r]; + } + sort(s, s + n, cmp2); + d[n] = 0; + for (int i = n - 1; i >= 0; --i) { + d[i] = d[i + 1]; + if (s[i].type == 1) { + d[i]++; + continue; + } + int l, r; + l = i; + r = n - 1; + while (r - l > 1) { + int mid = (l + r) >> 1; + if (s[mid].x - s[i].x > s[i].w + eps) + r = mid; + else + l = mid; + } + if (s[r].x - s[i].x < s[i].w + eps) + ans[s[i].id] = d[i]-d[r+1]; + else + ans[s[i].id] = d[i] - d[r]; + } + printf("Case #%d:\n",++ri); + for(int i=0;i +#include +#include +#include +using namespace std; +#define up(i,x,y) for(i=x;i<=y;i++) +#define down(i,x,y) for(i=x;i>=y;i--) +#define mem(a,b) memset(a,b,sizeof(a)) +#define w(x) while(x) +#define ll __int64 +ll n,x,y,z,t,dp[1505][1505],ss,cas=1,i,j,k,r,ans; +int main() +{ + scanf("%I64d",&ss); + w(ss--) + { + scanf("%I64d%I64d%I64d%I64d%I64d",&n,&x,&y,&z,&t); + mem(dp,0); + ans=n*t*x; + up(i,1,n) + up(j,0,i) + { + if(!j) + dp[i][j]=dp[i-1][j]+t*(i-j-1)*y; + else + dp[i][j]=max(dp[i-1][j]+(j*z+t)*max(0LL,(i-1-j))*y,dp[i-1][j-1]+((j-1)*z+t)*(i-j)*y); + ans=max(ans,dp[i][j]+(n-i)*(j*z+t)*(x+(i-j)*y)); + } + printf("Case #%I64d: %I64d\n",cas++,ans); + } + return 0; +} diff --git a/HDOJ/4940_autoAC.cpp b/HDOJ/4940_autoAC.cpp new file mode 100644 index 0000000..4eb0024 --- /dev/null +++ b/HDOJ/4940_autoAC.cpp @@ -0,0 +1,130 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int N = 1000; +const int M = 100000; +int n; +int ecnt, head[N], nx[M], to[M], va[M], cur_edge[N]; +int source, target, flow, pre[N], lev[N], qu[N], sign; +void addedge(int u, int v, int w) { + to[ecnt] = v; + nx[ecnt] = head[u]; + va[ecnt] = w; + head[u] = ecnt++; +} +bool bfs(int s, int t) { + std::fill(lev, lev + n, -1); + sign = t; + lev[t] = 0; + int st = 0, ed = 0; + qu[ed++] = t; + while (st != ed && lev[s] == -1) { + int u = qu[st++]; + for (int i = head[u]; i != -1; i = nx[i]) { + if (va[i ^ 1] > 0 && lev[to[i]] == -1) { + lev[to[i]] = lev[u] + 1; + qu[ed++] = to[i]; + } + } + } + return lev[s] != -1; +} +void push() { + int delta = INT_MAX, u, p; + for (u = target; u != source; u = to[p ^ 1]) { + p = pre[u]; + delta = std::min(delta, va[p]); + } + for (u = target; u != source; u = to[p ^ 1]) { + p = pre[u]; + va[p] -= delta; + if (!va[p]) { + sign = to[p ^ 1]; + } + va[p ^ 1] += delta; + } + flow += delta; +} +void dfs(int u) { + if (u == target) + push(); + else { + for (int i = cur_edge[u]; i != -1; i = nx[i]) { + if (va[i] > 0 && lev[u] == lev[to[i]] + 1) { + pre[to[i]] = i; + dfs(to[i]); + if (lev[sign] > lev[u]) { + return; + } + sign = target; + } + } + lev[u] = -1; + } +} +int nc, pc, tc; +int lx[M], ly[M], lv[M]; +void dinic(int s, int t, int node_cnt) { + source = s; + target = t; + n = node_cnt; + flow = 0; + while (bfs(source, target)) { + for (int i = 0; i < n; ++i) { + cur_edge[i] = head[i]; + } + dfs(source); + } +} +int in[500],out[500]; +void solve() { + int n,m; + memset(in,0,sizeof(in)); + memset(out,0,sizeof(out)); + scanf("%d%d",&n,&m); + fill(head,head+n+10,-1); + ecnt=0; + for(int i=0;i0) + { + sum+=in[i]; + addedge(s,i,in[i]); + addedge(i,s,0); + } + else + { + addedge(i,t,-in[i]); + addedge(t,i,0); + } + } + dinic(s,t,t+2); + if(flow==sum)puts("happy"); + else puts("unhappy"); +} +int main() { + int ri=0,tt; + scanf("%d",&tt); + while(tt--) + { + printf("Case #%d: ",++ri); + solve(); + } + return 0; +} diff --git a/HDOJ/4941_autoAC.cpp b/HDOJ/4941_autoAC.cpp new file mode 100644 index 0000000..3ead3b1 --- /dev/null +++ b/HDOJ/4941_autoAC.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=1e5+10; +map >mm; +maprow; +mapcol; +int main() +{ + int T,tt=0; + scanf("%d",&T); + while(T--) + { + row.clear(); + col.clear(); + mm.clear(); + int n,m,i,j,k,rr=0,cc=0,a,b,c,x,y; + scanf("%d%d%d",&n,&m,&k); + for(i=0;i +#include +#include +using namespace std ; +#pragma comment (linker,"/STACK:102400000,102400000") +#define REP( i , a , b ) for ( int i = a ; i < b ; ++ i ) +#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i ) +#define REV( i , a , b ) for ( int i = a ; i >= b ; -- i ) +#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 +typedef long long LL ; +const int MAXN = 100005 ; +const int mod = 1e9 + 7 ; +struct Node { + Node *c[2] , *f ; + int size[2] ; + int idx ; + LL v ; + Node () : v ( 0 ) {} +} ; +struct Seg_Tree { + Node node[MAXN] , *cur , *null ; + int product[MAXN << 2] ; + int val[MAXN] ; + int n , m ; + int cnt ; + void dfs ( Node* o ) { + if ( o -> c[0] != null ) dfs ( o -> c[0] ) ; + o -> idx = ++ cnt ; + o -> size[0] = o -> idx ; + if ( o -> c[0] != null ) { + o -> v += o -> c[0] -> v ; + o -> size[0] = o -> c[0] -> size[0] ; + } + o -> size[1] = o -> idx ; + if ( o -> c[1] != null ) dfs ( o -> c[1] ) ; + if ( o -> c[1] != null ) { + o -> v += o -> c[1] -> v ; + o -> size[1] = o -> c[1] -> size[1] ; + } + val[o -> idx] = o -> v % mod ; + } + void update ( int pos , int v , int o , int l , int r ) { + if ( l == r ) { + product[o] = v ; + return ; + } + int m = mid () ; + if ( pos <= m ) update ( pos , v , lson ) ; + else update ( pos , v , rson ) ; + product[o] = ( LL ) product[ls] * product[rs] % mod ; + } + int query ( int L , int R , int o , int l , int r ) { + if ( L <= l && r <= R ) return product[o] ; + int m = mid () ; + if ( R <= m ) return query ( L , R , lson ) ; + if ( m < L ) return query ( L , R , rson ) ; + return ( LL ) query ( L , R , lson ) * query ( L , R , rson ) % mod ; + } + void build ( int o , int l , int r ) { + if ( l == r ) { + product[o] = val[l] ; + return ; + } + int m = mid () ; + build ( lson ) ; + build ( rson ) ; + product[o] = ( LL ) product[ls] * product[rs] % mod ; + } + void init () { + cnt = 0 ; + null = node ; + cur = node + 1 ; + } + void rotate ( Node* o , int d ) { + Node* c = o -> c[d ^ 1] ; + Node* p = o -> f ; + o -> v -= ( c -> v ) - ( c -> c[d] -> v ) ; + c -> v += ( o -> v ) - ( c -> c[d] -> v ) ; + o -> c[d ^ 1] = c -> c[d] ; + c -> c[d] -> f = o ; + c -> f = p ; + if ( p != null ) { + if ( o == p -> c[0] ) p -> c[0] = c ; + else p -> c[1] = c ; + } + c -> c[d] = o ; + o -> f = c ; + } + void solve () { + int d , x ; + int w , l , r ; + init () ; + scanf ( "%d%d" , &n , &m ) ; + cur -> f = null ; + FOR ( i , 1 , n ) { + scanf ( "%d%d%d" , &w , &l , &r ) ; + cur -> v = w ; + cur -> c[0] = node + l ; + cur -> c[1] = node + r ; + if ( l ) cur -> c[0] -> f = node + i ; + if ( r ) cur -> c[1] -> f = node + i ; + ++ cur ; + } + dfs ( node + 1 ) ; + build ( root ) ; + while ( m -- ) { + scanf ( "%d%d" , &d , &x ) ; + Node* o = node + x ; + if ( d < 2 ) { + Node* c = o -> c[d] ; + if ( c == null ) continue ; + c -> size[d ^ 1] = o -> size[d ^ 1] ; + if ( c -> c[d ^ 1] != null ) o -> size[d] = c -> c[d ^ 1] -> size[d] ; + else o -> size[d] = o -> idx ; + rotate ( o , d ^ 1 ) ; + update ( o -> idx , o -> v % mod , root ) ; + update ( c -> idx , c -> v % mod , root ) ; + } else { + printf ( "%d\n" , query ( o -> size[0] , o -> size[1] , root ) ) ; + } + } + } +} T ; +int main () { + int t , cas = 0 ; + scanf ( "%d" , &t ) ; + while ( t -- ) { + printf ( "Case #%d:\n" , ++ cas ) ; + T.solve () ; + } + return 0 ; +} diff --git a/HDOJ/4944_autoAC.cpp b/HDOJ/4944_autoAC.cpp new file mode 100644 index 0000000..3ff73d8 --- /dev/null +++ b/HDOJ/4944_autoAC.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define LL __int64 +const int maxn=5e5+20; +LL mod; +LL val[maxn],dp[maxn]; +void fun(int n) +{ + for(LL i=1;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define eps 1e-10 +#define LL long long +#define INF 0x3f3f3f3f +#define PI 3.1415926535898 +#define zero(x) ((fabs(x)>= 1; + ans++; + } + return ans; +} +LL q_mod(LL a,LL b,LL n) +{ + LL ret=1; + LL tmp=a%n; + while(b) + { + if(b&0x1) ret=ret*tmp%n; + tmp=tmp*tmp%n; + b>>=1; + } + return ret; +} +LL Del(int n, int m) +{ + if(m > n) return 0LL; + LL ans = f[n]; + ans = (ans*q_mod((f[m]*f[n-m])%mod, mod-2, mod))%mod; + return ans; +} +void select() +{ + for(int i = 1; i <= 11; i++) + for(int j = 0; j < 2048; j++) use[i][j] = Del(num[i-1], j); +} +void change() +{ + select(); + for(int i = 0; i < 2048; i++) dp[1][i] = use[1][i]; + for(int i = 2; i <= 11; i++) + { + int cnt = (1<<(12-i)); + for(int j = 0; j < cnt; j++) + { + for(int k = 0; k <= 2*j+1; k += 2) + { + if(!use[i][j-k/2] || !(dp[i-1][k]+dp[i-1][k+1])) continue; + dp[i][j] += ((dp[i-1][k]+dp[i-1][k+1])*use[i][j-k/2])%mod; + } + dp[i][j] %= mod; + } + } + LL ans = 0LL; + ans = q_mod(2, num[20], mod); + LL ps = (dp[11][0]+dp[11][1])%mod; + ps = q_mod(2, n-num[20], mod)-ps; + ps = (ps+mod)%mod; + ans = (ans*ps)%mod; + printf("%I64d\n",ans); +} +void init() +{ + f[0] = 1LL; + for(LL i = 1; i < maxn; i++) f[i] = (f[i-1]*i)%mod; +} +int main() +{ + int Case = 1; + init(); + while(~scanf("%d",&n) && n) + { + memset(num, 0, sizeof(num)); + memset(dp, 0, sizeof(dp)); + int x; + for(int i = 0; i < n; i++) + { + scanf("%d",&x); + num[add(x)]++; + } + printf("Case #%d: ",Case++); + change(); + } + return 0; +} diff --git a/HDOJ/4946_autoAC.cpp b/HDOJ/4946_autoAC.cpp new file mode 100644 index 0000000..f0e33fe --- /dev/null +++ b/HDOJ/4946_autoAC.cpp @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include +using namespace std; +#define repf(i,a,b) for(int i=(a);i<=(b);i++) +#define sqr(a) ((a) * (a)) +#define dis(a, b) sqrt(sqr(a.x - b.x) + sqr(a.y - b.y)) +const int MAXN = 1010; +const double PI = acos(-1.0); +int top; +struct Point { + double x; + double y; + double v; + int id; + Point(double a = 0, double b = 0) : x(a), y(b) {} + friend bool operator < (const Point &l, const Point &r) { + return l.y < r.y || (l.y == r.y && l.x < r.x); + } +} p[MAXN], res[MAXN], all[MAXN]; +double mult(Point a, Point b, Point o) { + return (a.x - o.x) * (b.y - o.y) > (b.x - o.x) * (a.y - o.y); +} +void Graham(int n) { + top = 1; + sort(p, p + n); + if (n == 0) { + top = 0; + return; + } + res[0] = p[0]; + if (n == 1) { + top = 1; + return; + } + res[1] = p[1]; + if (n == 2) { + top = 2; + return; + } + res[2] = p[2]; + for (int i = 2; i < n; i++) { + while (top && (mult(p[i], res[top], res[top - 1]))) + top--; + res[++top] = p[i]; + } + int len = top; + res[++top] = p[n - 2]; + for (int i = n - 3; i >= 0; i--) { + while (top != len && (mult(p[i], res[top], res[top - 1]))) + top--; + res[++top] = p[i]; + } +} +int id[MAXN]; +int n; +double mmax; +int main() { + int cas = 1; + while (~scanf("%d", &n) && n) { + mmax = 0; + repf (i, 0, n - 1) { + scanf("%lf%lf%lf", &all[i].x, &all[i].y, &all[i].v); + all[i].id = i; + mmax = max(mmax, all[i].v); + } + memset(id, 0, sizeof(id)); + repf (i, 0, n - 1) + repf (j, i + 1, n - 1) { + if (all[i].x == all[j].x && all[i].y == all[j].y && all[i].v == all[j].v) { + all[j].v = 0; + id[i] = id[j] = -1; + } + } + int cnt = 0; + repf (i, 0, n - 1) { + if (all[i].v == mmax) + p[cnt++] = all[i]; + } + if (mmax) { + Graham(cnt); + repf (i, 0, top - 1) { + if (id[res[i].id] != -1) + id[res[i].id] = 1; + } + } + printf("Case #%d: ", cas++); + repf (i, 0, n - 1) { + printf("%d", id[i] > 0); + } + puts(""); + } + return 0; +} diff --git a/HDOJ/4947_autoAC.cpp b/HDOJ/4947_autoAC.cpp new file mode 100644 index 0000000..83a5f9d --- /dev/null +++ b/HDOJ/4947_autoAC.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define CLR(a,b) memset(a,b,sizeof(a)) +typedef long long LL; +const int N = 200000+20; +bool check[N]; +int mu[N],prime[N]; +vector fac[N]; +LL f[N]; +int l,q; +void Mobius() +{ + CLR(check, 0); + mu[1] = 1; + int tot = 0; + for(int i = 2; i < N ; i++){ + if(!check[i]){ + prime[tot ++] = i; + mu[i] = -1; + } + for(int j = 0 ;j < tot; j ++){ + if(i * prime[j] >= N)break; + check[i * prime[j]] = true; + if(i % prime[j] == 0){ + mu[i * prime[j]] = 0; + break; + }else{ + mu[i * prime[j]] = -mu[i]; + } + } + } + for(int i = 1 ;i < N ; i++){ + for(int j = i ; j < N ; j += i){ + fac[j].push_back(i); + } + } +} +inline LL sum(int p){ + LL s = 0; + while(p > 0){ + s += f[p]; + p -= p & (-p); + } + return s; +} +inline void add(int p,int v){ + while(p <= l){ + f[p] += v; + p += (p) & (-p); + } +} +void update(int n,int d,int v){ + if(n % d != 0)return; + n = n/d; + for(int i = 0 ;i < fac[n].size() ; i++){ + int q = fac[n][i]; + add(q * d, v * mu[q]); + } +} +LL query(int p) +{ + LL ans = 0; + for(int i = 1,last = i ; i <= p ; i = last + 1){ + last = p/(p/i); + ans += (LL)(p/i) * (sum(last) - sum(i-1)) ; + } + return ans; +} +int main() +{ + Mobius(); + int cas = 0; + while(~scanf("%d%d",&l,&q)){ + if(l == 0 && q == 0)break; + CLR(f, 0); + cas ++; + printf("Case #%d:\n",cas); + while(q--){ + int t; + scanf("%d",&t); + if(t == 1){ + int n,d,v; + scanf("%d%d%d",&n,&d,&v); + update(n, d, v); + }else{ + int x; + scanf("%d",&x); + printf("%I64d\n",query(x)); + } + } + } + return 0; +} diff --git a/HDOJ/4948_autoAC.cpp b/HDOJ/4948_autoAC.cpp new file mode 100644 index 0000000..5cff49e --- /dev/null +++ b/HDOJ/4948_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 0x3f3f3f3f +#pragma comment(linker, "/STACK:16777216") +#define eps 1e-6 +#define ll long long +using namespace std; +const int maxn=505; +int n,in[maxn],vis[maxn]; +char s[maxn][maxn]; +int main() +{ + int i,j; + while(~scanf("%d",&n)&&n) + { + memset(in,0,sizeof in); + for(i=1;i<=n;i++) + { + scanf("%s",s[i]+1); + for(j=1;j<=n;j++) + if(s[i][j]=='1') + in[j]++; + } + vector ans; + memset(vis,0,sizeof vis); + int maxin,p,flag=1; + while(flag) + { + flag=0,maxin=-1,p=0; + for(i=1;i<=n;i++) + { + if(!vis[i]&&maxin=0;i--) + printf(" %d",ans[i]); + puts(""); + } + return 0; +} diff --git a/HDOJ/4949_autoAC.cpp b/HDOJ/4949_autoAC.cpp new file mode 100644 index 0000000..b0605cd --- /dev/null +++ b/HDOJ/4949_autoAC.cpp @@ -0,0 +1,109 @@ +#include +#include +#include +using namespace std; +#define HASH 100007 +#define STATE 500010 +#define maxd 15 +int maze[maxd][maxd]; +int code[maxd]; +int n,m; +struct HASHMAP{ + int head[HASH]; + int state[STATE],nxt[STATE]; + int f[STATE]; + int sz; + void clear(){sz=0;memset(head,-1,sizeof(head));} + void push(int st,int ans){ + int h=st%HASH; + for(int i=head[h];i!=-1;i=nxt[i]){ + if(st==state[i]){ + f[i] = f[i]=0;--i) code[i]=st&3,st>>=2; +} +int encode(){ + int ret=0; + for(int i=0;i<=m;++i) ret=ret<<2|code[i]; + return ret; +} +void shift(){ + for(int i=m;i;--i) code[i]=code[i-1]; + code[0]=0; +} +int ans; +int zo,oz,oo; +void dpblank(int i,int j,int cur){ + int mv = j==m?2:0; + int all = (1<<(2*(m+1)-mv) ) -1; + for(int k=0;k>(2*(j-1))), up = st&(oo>>(2*j)); + int L = left>>(2*(m-j+1)), U = up>>(2*(m-j)); + int cnt = ((L>>1)+(U>>1))&1; + if(i==1 || U==2 || maze[i-1][j]==U){ + int st2 = st^left^up; + if(cnt) st2 = st2 | (zo>>(2*(j-1))) | (zo>>(2*j)); + hm[cur^1].push((st2>>mv)&all, hm[cur].f[k]); + } + if(hm[cur].f[k]+2>(2*(j-1))) | (zo>>(2*j)); + hm[cur^1].push((st2>>mv)&all, hm[cur].f[k]+2); + } + if(hm[cur].f[k]+11 && L!=2) st2 = st2 ^ (zo>>(2*(j-2))); + st2 = st2 | (oz>>(2*(j-1))) | (oz>>(2*j)); + hm[cur^1].push((st2>>mv)&all, hm[cur].f[k]+1); + } + } +} +void solve(){ + zo = 1<<(2*m); + oz = 2<<(2*m); + oo = 3<<(2*m); + int cur=0; + hm[0].clear(); + hm[0].push(0,0); + for(int i=1;i<=n;++i){ + for(int j=1;j<=m;++j){ + hm[cur^1].clear(); + dpblank(i,j,cur); + cur^=1; + } + } + for(int k=0;k +int main() +{ + __int64 h,a,b,k,cas=1; + while(~scanf("%I64d%I64d%I64d%I64d",&h,&a,&b,&k),h+a+b+k) + { + if(a>=h||(a-b)*k-b>0||(a-b)*(k-1)+a>=h) + printf("Case #%I64d: YES\n",cas++); + else + printf("Case #%I64d: NO\n",cas++); + } + return 0; +} diff --git a/HDOJ/4952_autoAC.cpp b/HDOJ/4952_autoAC.cpp new file mode 100644 index 0000000..252ea9e --- /dev/null +++ b/HDOJ/4952_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define LL __int64 +int main() +{ + LL x, k; + int cse = 1; + while(scanf("%I64d %I64d",&x,&k)!=EOF){ + if(!x) break; + printf("Case #%d: ",cse++); + LL i = 1; + LL tmp = x / i; + while(tmp >= i+1 && i +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const int maxn=1005; +const int mod=1000000007; +int a[maxn],n; +bool vis[maxn]; +ll c[maxn][maxn],b[maxn][maxn]; +ll f[maxn][maxn]; +void init() +{ + for(int i=0; i=mod)c[i][j]-=mod; + } + for(int i=0; i=mod)ret-=mod; +} +int main() +{ + init(); + int ncase=0; + while(scanf("%d",&n)&&n) + { + memset(vis,0,sizeof(vis)); + bool sign=0; + int cc=0; + for(int i=1; i<=n; i++) + { + scanf("%d",&a[i]); + if(a[i])cc++; + for(int j=1; j<=a[i]; j++) + { + int x; + scanf("%d",&x); + if(vis[x])sign=1; + vis[x]=1; + } + } + if(sign||(n==1&&cc)||(n>1&&cc<2))printf("Case #%d: 0\n",++ncase); + else + { + for(int i=0; i<=n; i++) + for(int j=0; j<=i; j++)f[i][j]=0; + int sum=0,sum2=0; + f[0][0]=1; + for(int i=0; ia[i+1])break; + pd(f[i+1][j+1-k],f[i][j]*c[a[i+1]][k]%mod*b[j][k]%mod); + pd(f[i+1][j-k],f[i][j]*c[a[i+1]][k]%mod*c[sum-(sum2-j)][1]%mod*b[j][k]%mod); + } + } + else + { + for(int k=0; k<=j; k++) + { + if(k>a[i+1])break; + pd(f[i+1][j-k],f[i][j]*c[a[i+1]][k]%mod*b[j][k]%mod); + } + } + } + sum+=a[i+1]; + if(a[i+1])sum2++; + } + printf("Case #%d: %I64d\n",++ncase,f[n][0]); + } + } + return 0; +} diff --git a/HDOJ/4956_autoAC.cpp b/HDOJ/4956_autoAC.cpp new file mode 100644 index 0000000..517ea48 --- /dev/null +++ b/HDOJ/4956_autoAC.cpp @@ -0,0 +1,46 @@ +#include +typedef __int64 LL; +bool Judge(LL tt) +{ + LL sumo = 0, sume = 0; + LL i = -1; + while(tt) + { + i++; + LL t = tt%10; + if(i%2) + sumo += t; + else + sume += t; + tt /= 10; + } + if(sume - sumo == 3) + return true; + return false; +} +int main() +{ + int T; + LL l, r; + LL i, j; + scanf("%d",&T); + while(T--) + { + scanf("%I64d%I64d",&l,&r); + for(i = l; ; i++) + { + if(i%11 == 3) + break; + } + for(j = i; j <= r; j+=11) + { + if(!Judge(j)) + break; + } + if(j > r) + printf("-1\n"); + else + printf("%I64d\n",j); + } + return 0; +} diff --git a/HDOJ/4958_autoAC.cpp b/HDOJ/4958_autoAC.cpp new file mode 100644 index 0000000..86a7c41 --- /dev/null +++ b/HDOJ/4958_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 0x3f3f3f3f +#define ll long long +#define mod 1000000007 +using namespace std; +double ans; +double visit[1005][1005]; +double dfs(int ji,int ou) +{ + if(ji+ou<=0)return 0; + if(visit[ji][ou])return visit[ji][ou]; + if(ji%2==1) + return visit[ji][ou]=dfs(ji-1,ou); + if(ji) + { + if(ou) + return visit[ji][ou]=(dfs(ji-1,ou)*ji+dfs(ji,ou-1)*ou)/(ji+ou)+ji+ou; + else + return visit[ji][ou]=dfs(ji-1,ou)+ji+ou; + } + return visit[ji][ou]=dfs(ji,ou-1)+ji+ou; +} +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + memset(visit,0,sizeof(visit)); + ans=0; + int n; + scanf("%d",&n); + int ji=0,ou=0; + for(int i=0; i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define sqr(x) ((x)*(x)) +#define LL long long +#define INF 0x3f3f3f3f +#define PI acos(-1.0) +#define eps 1e-10 +#define mod 1000000007 +using namespace std; +int cnt=0; +typedef pair qf; +qf operator + (qf a,qf b) +{ + return make_pair((a.first+b.first)%mod,(a.second+b.second)%mod); +} +qf operator * (qf a,qf b) +{ + if (a.first<0) a.first+=mod; + if (b.first<0) b.first+=mod; + if (a.second<0) a.second+=mod; + if (b.second<0) b.second+=mod; + return make_pair((((LL)a.first*(LL)b.first)%mod+((LL)a.second*(LL)b.second)%mod*5ll)%mod, + (((LL)a.first*(LL)b.second)%mod+((LL)a.second*(LL)b.first)%mod)%mod); +} +qf pow(qf a, LL x) +{ + qf res(1,0); + qf multi=a; + while (x) + { + if (x&1) + { + res=res*multi; + } + multi=multi*multi; + x/=2; + } + return res; +} +LL pow(LL a,LL b) +{ + LL res=1; + LL multi=a; + while (b) + { + if (b&1) + { + res=res*multi%mod; + } + multi=multi*multi%mod; + b/=2; + } + return res; +} +qf acce(qf a,LL b) +{ + qf ans=make_pair(1,0); + qf powe=a; + qf sum=a; + qf multi=make_pair(1,0); + while (b) + { + if (b&1) + { + ans=ans+(multi*sum); + multi=multi*powe; + } + sum=sum*(powe+make_pair(1,0)); + powe=powe*powe; + b/=2; + } + return ans; +} +LL inv[100005]; +qf r1[100005],r2[100005]; +void egcd (LL a,LL b,LL &x,LL &y) +{ + if (b==0) + { + x=1,y=0; + return ; + } + egcd(b,a%b,x,y); + LL t=x; + x=y;y=t-a/b*y; +} +int main() +{ + LL x,y; + for (LL i=1;i<=100000;i++) + { + egcd(i,mod,x,y); + x=(x+mod)%mod; + inv[i]=x; + } + r1[0]=make_pair(1,0); + r2[0]=make_pair(1,0); + for (int i=1;i<=100000;i++) + { + r1[i]=r1[i-1]*make_pair(1,1); + r2[i]=r2[i-1]*make_pair(1,-1); + } + int T; + scanf("%d",&T); + while (T--) + { + cnt=0; + LL n,m; + scanf("%I64d%I64d",&n,&m); + qf ans=make_pair(0,0); + LL Ca=1; + LL v=pow(inv[2],m); + for (LL i=0;i<=m;i++) + { + qf p(Ca,0); + qf tmp=r1[i]*r2[m-i]*make_pair(v,0); + tmp=acce(tmp,n); + tmp=tmp*p; + ans=ans+tmp; + Ca=Ca*(m-i)%mod; + Ca=Ca*inv[i+1]%mod; + } + LL aa=(LL)ans.first; + printf("%I64d\n",aa); + } + return 0; +} diff --git a/HDOJ/4960_autoAC.cpp b/HDOJ/4960_autoAC.cpp new file mode 100644 index 0000000..d9b168f --- /dev/null +++ b/HDOJ/4960_autoAC.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +using namespace std; +#define up(i,x,y) for(i=x;i<=y;i++) +#define down(i,x,y) for(i=x;i>=y;i--) +#define mem(a,b) memset(a,b,sizeof(a)) +#define w(x) while(x) +#define inf 99999999 +#define l 5005 +#define s(a) scanf("%d",&a) +int dp[l],a[l],cost[l],lnum,rnum,lsum,rsum,len,i,j,ll[l],rr[l],ans,n; +int main() +{ + w((s(n),n)) + { + up(i,1,n) + s(a[i]); + up(i,1,n) + s(cost[i]); + len=0; + for(i=1,j=n; i=j) + break; + if(lsum +#include +#include +#include +using namespace std; +const int maxn=100005; +int a[maxn]; +int b[maxn]; +int c[maxn]; +int num[maxn]; +int n; +vector f[maxn]; +void init() +{ + int i,j; + for(i=1;i0;i--) + { + int sz=f[a[i]].size(); + if(num[a[i]]==0) c[i]=a[i]; + else c[i]=a[num[a[i]]]; + for(j=0;j +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +struct Point{ + double x,y; + Point(double x=0,double y=0):x(x),y(y){} +}; +typedef Point Vector; +Vector operator + (Vector A,Vector B){return Vector(A.x+B.x,A.y+B.y);} +Vector operator - (Vector A,Vector B){return Vector(A.x-B.x,A.y-B.y);} +Vector operator * (Vector A,double p){return Vector(A.x*p,A.y*p);} +Vector operator / (Vector A,double p){return Vector(A.x/p,A.y/p);} +bool operator <(const Point& a, const Point& b) +{ + return a.x0)e[t++].dir=1; + else e[t++].dir=-1; + } + } + } + sort(e,e+t,cmp); + sort(f,f+tot,cmp2); + int ans=0,now=0; + for(i=0,j=0;i0)j++; + if(j=0)continue; + ans=max(ans,now); + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4963_autoAC.cpp b/HDOJ/4963_autoAC.cpp new file mode 100644 index 0000000..a4a3fe7 --- /dev/null +++ b/HDOJ/4963_autoAC.cpp @@ -0,0 +1,136 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=44; +const int maxm=(1<<20)+10; +const int INF=1e9; +char a[maxn]; +int c[maxn],b[maxn],x,y,xx,yy,sx,sy,t,f[maxn],g[maxm],len[maxn]; +struct node{ + int id,w,flag; + bool operator <(const node &a)const{ + if(id==a.id)return w>1; + } + return x; +} +void init() +{ + for(int i=0;i<=22;i++) + { + f[i]=(1<>(yy-xx))^x)return ; + e[t].flag=0; + e[t].id=len[yy-xx]+(y&f[yy-xx]); + e[t++].w=sy-sx; +} +void judge2() +{ + int i,j,k,p; + if(x^(y&f[xx]))return ; + e[t].flag=1; + e[t].id=len[yy-xx]+(y>>xx); + e[t++].w=sy-sx; +} +int main() +{ + init(); + int n; + while(scanf("%d",&n)!=EOF) + { + if(n==0)break; + int i,j,k=0,ans=INF; + scanf("%s",a); + for(i=0;i<2*n;i++) + { + b[i]=a[i]-'a'; + k+=b[i]; + } + for(i=0;in-g[i])continue; + x=y=xx=yy=sx=sy=0; + for(j=n-1;j>=0;j--) + { + if((1<n-g[i])continue; + x=y=xx=yy=sx=sy=0; + for(j=n-1;j>=0;j--) + { + if((1< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define CLR(x,y) memset(x,y,sizeof(x)) +#define eps 1e-9 +#define INF 0x3f3f3f3f +using namespace std; +typedef long long ll; +typedef long double ld; +typedef pair pll; +typedef complex point; +typedef pair pii; +typedef pair piii; +template +inline bool read(T &n) +{ + T x = 0, tmp = 1; + char c = getchar(); + while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar(); + if(c == EOF) return false; + if(c == '-') c = getchar(), tmp = -1; + while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar(); + n = x*tmp; + return true; +} +template +inline void write(T n) +{ + if(n < 0) + { + putchar('-'); + n = -n; + } + int len = 0,data[20]; + while(n) + { + data[len++] = n%10; + n /= 10; + } + if(!len) data[len++] = 0; + while(len--) putchar(data[len]+48); +} +char str[100], ans[10010]; +int len; +int getmatch(int l) +{ + int p = 1; + for (int r = l + 1; ; r++) + { + if (str[r] == '(') p++; + else if (str[r] == ')') p--; + if (p == 0) return r; + } +} +string getStr(int &w) +{ + string ret = ""; + while (islower(str[w]) or isupper(str[w]) or isdigit(str[w])) + ret += str[w++]; + return ret; +} +void getHtmltag(int &w, string &s1, string &s2) +{ + string name = "", id = "", cla = ""; + name = getStr(w); + while (str[w] == '#' || str[w] == '.') + { + if (str[w] == '#') id = getStr(++w); + else + { + if (cla != "") cla += ' '; + cla += getStr(++w); + } + } + s1 = "<" + name; + if (id != "") + s1 += " id=\""+ id + "\""; + if (cla != "") + s1 += " class=\""+ cla + "\""; + s1 += ">"; + s2 = ""; +} +string solve(int l, int r) +{ + if (l > r) return ""; + if (str[l] == '(') + { + int k = getmatch(l); + return solve(l + 1, k - 1) + solve(k + 1, r); + } + else + { + string s1, s2, s3, ret; + getHtmltag(l, s1, s2); + int k = 0; + if (str[l] == '*') + { + l++; + while (isdigit(str[l])) + k = k * 10 + str[l++] - '0'; + } + else k = 1; + s3 = solve(l + 1, r); + ret = ""; + while (k--) + ret += s1 + s3 + s2; + return ret; + } +} +int main() +{ + int T; + read(T); + while (T --) + { + scanf("%s", str); + cout< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int mod=6; +struct matrix{ + int f[6][6]; +}; +int A[1001][6],B[6][1001],C[1001][6],D[1001][1001]; +matrix mul(matrix a,matrix b,int n) +{ + matrix c; + memset(c.f,0,sizeof(c.f)); + int i,j,k; + for(i=0;i>1; + } + return s; +} +int main() +{ + int n,K; + while(scanf("%d%d",&n,&K)!=EOF) + { + if(n==0&&K==0)break; + int i,j,k; + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int INF=1<<30; +const int maxn=500+50; +const int maxm=2000+10; +struct edge{ + int u,v,w; + edge(int u=0,int v=0,int w=0):u(u),v(v),w(w){} +}e[maxn+maxm]; +int sum[maxn],a[maxn],tot,in[maxn],pre[maxn],id[maxn],vis[maxn]; +void add(int u,int v,int w) +{ + e[tot++]=edge(u,v,w); +} +int Directed_MST(int root,int numv,int nume) +{ + int i,j,k,u,v,ans=0; + while(true) + { + for(i=0;isum[i];j--)add(j,j-1,0); + add(sum[n],sum[i],0); + } + int c,d,l1,l2,money; + for(i=0;i +#include +#include +using namespace std; +struct info{ + int s; + int x; + int t; +}; +const int MAX = 50010; +int N,x,t; +char str[20]; +info a[MAX]; +int b[MAX]; +int ans; +struct interval{ + int left, right; + int sum, rsum; +}; +struct SegmentTree{ + static const int MAX = 50010; + interval node[MAX<<3]; + #define ls(o) (o<<1) + #define rs(o) (o<<1|1) + void build(int l, int r, int o){ + node[o].left = l; + node[o].right = r; + node[o].sum = node[o].rsum = 0; + if(l == r) return; + int mid = (l + r)>>1; + build(l,mid,ls(o)); + build(mid+1,r,rs(o)); + } + void pushup(int o){ + node[o].sum = node[rs(o)].sum + node[ls(o)].sum; + node[o].rsum = max(node[rs(o)].rsum,node[ls(o)].rsum + node[rs(o)].sum); + } + void update(int value,int pos,int o){ + if(node[o].left == node[o].right && + node[o].left == pos){ + node[o].sum = node[o].rsum = value; + return ; + } + int mid = (node[o].left + node[o].right) >> 1; + if(pos <= mid) update(value,pos,ls(o)); + else update(value,pos,rs(o)); + pushup(o); + } + void getans(int v,int o){ + if(node[o].left == node[o].right){ + ans = b[node[o].left]; + return; + } + if(v + node[rs(o)].rsum > 0) + getans(v,rs(o)); + else + getans(v + node[rs(o)].sum,ls(o)); + } + void query(int &v,int L, int R, int o){ + if(~ans) return; + if(L <= node[o].left && R >= node[o].right){ + if(v + node[o].rsum <= 0) v += node[o].sum; + else getans(v,o); + return; + } + int mid = (node[o].left + node[o].right) >> 1; + if(R > mid) query(v,L,R,rs(o)); + if(L <= mid) query(v,L,R,ls(o)); + } +}; +SegmentTree tree; +int main(void) +{ + int cas = 1; + while(scanf("%d", &N),N){ + for(int i = 0 ; i < N; ++i){ + scanf("%s",str); + if(str[1] == 'u'){ + a[i].s = 1; + scanf("%d", &a[i].x); + } + else if(str[1] == 'o') + a[i].s = 2; + else + a[i].s = 3; + scanf("%d", &a[i].t); + b[i] = a[i].t; + } + sort(b,b + N); + for(int i = 0 ; i < N; ++i) + a[i].t = lower_bound(b, b + N, a[i].t) - b + 1; + memset(b,0,sizeof(b)); + for(int i = 0 ; i < N; ++i) + if(a[i].s == 1) + b[a[i].t] = a[i].x; + printf("Case #%d:\n",cas++); + tree.build(1,N,1); + for(int i = 0 ; i < N; ++i){ + if(a[i].s == 1) + tree.update(1,a[i].t,1); + else if(a[i].s == 2) + tree.update(-1,a[i].t,1); + else{ + int v =0; + ans = -1; + tree.query(v,1,a[i].t,1); + printf("%d\n",ans); + } + } + } + return 0; +} diff --git a/HDOJ/4968_autoAC.cpp b/HDOJ/4968_autoAC.cpp new file mode 100644 index 0000000..a75a958 --- /dev/null +++ b/HDOJ/4968_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +using namespace std; +#define up(i,x,y) for(i=x;i<=y;i++) +#define up2(i,x,y) for(i=x;y;i++) +#define mem(a,b) memset(a,b,sizeof(a)) +#define w(x) while(x) +#define inf 99999999 +double a[105],dp[1005][105]; +int i,j,k,n,m,t,sum; +int main() +{ + up(i,60,100) + { + if(i<=69) a[i]=2; + else if(i<=74) a[i]=2.5; + else if(i<=79) a[i]=3; + else if(i<=84) a[i]=3.5; + else a[i]=4; + } + scanf("%d",&t); + w(t--) + { + scanf("%d%d",&m,&n); + sum=n*m; + up(i,0,sum) + up(j,0,n) + dp[i][j]=inf; + up(i,60,100) + dp[i][1]=a[i]; + up(j,2,n) + up(i,0,sum) + up2(k,60,(k<=100&&(i-k)>=60*(j-1))) + dp[i][j]=min(dp[i][j],dp[i-k][j-1]+dp[k][1]); + printf("%.4f ",dp[sum][n]/n); + up(i,0,sum) + up(j,0,n) + dp[i][j]=0; + up(i,60,100) + dp[i][1]=a[i]; + up(j,2,n) + up(i,0,sum) + up2(k,60,(k<=100&&(i-k)>=60*(j-1))) + dp[i][j]=max(dp[i][j],dp[i-k][j-1]+dp[k][1]); + printf("%.4f\n",dp[sum][n]/n); + } + return 0; +} diff --git a/HDOJ/4969_autoAC.cpp b/HDOJ/4969_autoAC.cpp new file mode 100644 index 0000000..ea65c6c --- /dev/null +++ b/HDOJ/4969_autoAC.cpp @@ -0,0 +1,17 @@ +#include +#include +#include +using namespace std; +int v1,v2,d,r; +int main() +{ + int T; + cin>>T; + while(T--){ + scanf("%d%d%d%d",&v1,&v2,&r,&d); + double ans = r/(double)v1*v2*asin(v1/(double)(v2)); + if(ans>d)printf("Why give up treatment\n"); + else printf("Wake up to code\n"); + } + return 0; +} diff --git a/HDOJ/4970_autoAC.cpp b/HDOJ/4970_autoAC.cpp new file mode 100644 index 0000000..02e84f2 --- /dev/null +++ b/HDOJ/4970_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +const int N = 100005; +typedef __int64 LL; +LL attack[N]; +int main() +{ + int n, l, r, m, k, pos; + LL d, hp; + while(~scanf("%d",&n) && n) { + memset(attack, 0, sizeof(attack)); + scanf("%d",&m); + while(m--) { + scanf("%d%d%I64d", &l, &r, &d); + attack[l] += d; + attack[r+1] -= d; + } + for(int i = 2; i <= n; i++) + attack[i] += attack[i-1]; + for(int i = n - 1; i > 0; i--) + attack[i] += attack[i+1]; + int ans = 0; + scanf("%d",&k); + while(k--) { + scanf("%I64d%d",&hp, &pos); + if(attack[pos] < hp) + ans++; + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4971_autoAC.cpp b/HDOJ/4971_autoAC.cpp new file mode 100644 index 0000000..fc858d5 --- /dev/null +++ b/HDOJ/4971_autoAC.cpp @@ -0,0 +1,252 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define mt(a,b) memset(a,b,sizeof(a)) +using namespace std; +const int M = 123456; +const int inf = 0x7f7f7f7f; +int profit[30],cost[60]; +class Tarjan { +public: + struct E { + int u,v,next; + } e[M<<4]; + int le,head[M],Index,Bcnt,num[M],belong[M],dfn[M],low[M]; + bool instack[M]; + stack s; + void tarjan(int u) { + dfn[u]=low[u]=++Index; + instack[u]=true; + s.push(u); + int v; + for(int i=head[u]; ~i; i=e[i].next) { + v=e[i].v; + if(!dfn[v]) { + tarjan(v); + low[u]=min(low[u],low[v]); + } else if(instack[v]) { + low[u]=min(low[u],dfn[v]); + } + } + if(dfn[u]==low[u]) { + Bcnt++; + do { + v=s.top(); + s.pop(); + instack[v]=false; + belong[v]=Bcnt; + num[Bcnt]++; + } while(u!=v); + } + } + void init() { + le=Index=Bcnt=0; + mt(head,-1); + mt(num,0); + mt(dfn,0); + mt(low,0); + mt(instack,0); + while(!s.empty()) s.pop(); + } + void add(int u,int v) { + e[le].u=u; + e[le].v=v; + e[le].next=head[u]; + head[u]=le++; + } + void solve(int n) { + for(int i=1; i<=n; i++) { + if(!dfn[i]) { + tarjan(i); + } + } + } + int getbcnt() { + return Bcnt; + } + int getbelong(int id) { + return belong[id]; + } + int getnum(int id) { + return num[id]; + } +} gx; +class Dinic { + struct E { + int u,v,next,flow; + } e[M<<1]; + int le,flow,head[M],temp[M],cur[M],level[M],path[M]; + bool used[M]; + queue q; +public: + int getflow() { + return flow; + } + bool bfs(int s,int t) { + mt(level,-1); + while(!q.empty()) q.pop(); + q.push(s); + level[s]=1; + while(!q.empty()) { + int u=q.front(); + q.pop(); + for(int i=head[u]; ~i; i=e[i].next) { + int v=e[i].v; + if(level[v]==-1&&e[i].flow) { + level[v]=level[u]+1; + q.push(v); + if(v==t) return true; + } + } + } + return false; + } + void init() { + le=0; + mt(head,-1); + } + void add(int u,int v,int flow) { + e[le].u=u; + e[le].v=v; + e[le].flow=flow; + e[le].next=head[u]; + head[u]=le++; + e[le].u=v; + e[le].v=u; + e[le].flow=0; + e[le].next=head[v]; + head[v]=le++; + } + void solve(int s,int t) { + int p,now,tempp; + bool flag; + flow=0; + while(bfs(s,t)) { + for(int i=0; i +#include +#include +#include +using namespace std; +const int maxn=1e5+100; +int n,a[maxn]; +int main() +{ + int T,cas=1; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + for(int i=1;i<=n;i++) + scanf("%d",&a[i]); + bool is=true; + for(int i=2;i<=n;i++) + if(abs(a[i]-a[i-1])>3||(a[i]==a[i-1]&&a[i]!=1)) + { + is=false; + break; + } + if(!is) + { + printf("Case #%d: 0\n",cas++); + continue; + } + int cnt=0; + for(int i=2;i<=n;i++) + { + if(a[i]==2&&a[i-1]==1) + cnt++; + if(a[i]==1&&a[i-1]==2) + cnt++; + } + if(a[n]) + printf("Case #%d: %d\n",cas++,cnt*2+2); + else + printf("Case #%d: %d\n",cas++,cnt+1); + } + return 0; +} diff --git a/HDOJ/4973_autoAC.cpp b/HDOJ/4973_autoAC.cpp new file mode 100644 index 0000000..a06c073 --- /dev/null +++ b/HDOJ/4973_autoAC.cpp @@ -0,0 +1,165 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define ll __int64 +#define eps 1e-8 +template +inline void scan_d(T &ret) { + char c; ret=0; + while((c=getchar())<'0'||c>'9'); + while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar(); +} +struct Tree +{ + ll zuo; + ll flag; + bool isleaf; + ll maxnum,num; +}; +Tree T[50000*4]; +ll ans; +void build(ll l, ll r, ll rt) +{ + T[rt].flag = 1; + if(l == r) + { + T[rt].isleaf = 1; + T[rt].zuo = 0; + T[rt].maxnum = T[rt].num = 1; + return; + } + ll m = (l+r)>>1; + T[rt].isleaf = 0; + T[rt].zuo = m-l+1; + T[rt].maxnum = 1; + build(l,m,rt<<1); + build(m+1,r,rt<<1|1); + T[rt].num=T[rt<<1].num+T[rt<<1|1].num; +} +void pushup(ll rt) +{ + T[rt].maxnum = max(T[rt<<1].maxnum,T[rt<<1|1].maxnum); + T[rt].num = T[rt<<1].num+T[rt<<1|1].num; + T[rt].zuo = T[rt<<1].num; +} +void pushdown(ll rt) +{ + if(T[rt].flag != 1) + { + T[rt<<1].maxnum *= T[rt].flag; + if(!T[rt<<1].isleaf) T[rt<<1].zuo *= T[rt].flag; + T[rt<<1].num *= T[rt].flag; + T[rt<<1|1].maxnum *= T[rt].flag; + if(!T[rt<<1|1].isleaf) T[rt<<1|1].zuo *= T[rt].flag; + T[rt<<1|1].num *= T[rt].flag; + T[rt<<1].flag *= T[rt].flag; + T[rt<<1|1].flag *= T[rt].flag; + T[rt].flag = 1; + } +} +void update(ll L, ll R, ll l, ll r, ll rt) +{ + if(T[rt].isleaf == 1) + { + if(L >= l && R <= r) + { + T[rt].num+=R-L+(ll)1; + T[rt].maxnum = T[rt].num; + } + else if(L >= l && L <= r && R >= r) + { + T[rt].num+=r-L+(ll)1; + T[rt].maxnum = T[rt].num; + } + else if(L <= l && R >= r) + { + T[rt].num+=r-l+(ll)1; + T[rt].maxnum = T[rt].num; + } + else if(L <= l && R >= l && R <= r) + { + T[rt].num+=R-l+(ll)1; + T[rt].maxnum = T[rt].num; + } + return; + } + if(L <= l && R >= r) + { + T[rt].flag *= (ll)2; + T[rt].num *= (ll)2; + T[rt].maxnum *= (ll)2; + T[rt].zuo *= (ll)2; + return; + } + pushdown(rt); + ll m = l+T[rt].zuo-(ll)1; + if(L <= m) update(L,R,l,m,rt<<1); + if(R > m) update(L,R,m+1,r,rt<<1|1); + pushup(rt); +} +void query(ll L, ll R, ll l, ll r, ll rt) +{ + if(T[rt].isleaf == 1) + { + if(L >= l && R <= r) + ans = max(ans,(ll)(R-L+1)); + else if(L >= l && L <= r && R >= r) + ans = max(ans,(ll)(r-L+1)); + else if(L <= l && R >= r) + ans = max(ans,(ll)(r-l+1)); + else if(L <= l && R >= l && R <= r) + ans = max(ans,(ll)(R-l+1)); + return; + } + if(L <= l && R >= r) + { + ans = max(ans,T[rt].maxnum); + return; + } + pushdown(rt); + ll m = l+T[rt].zuo-(ll)1; + if(L <= m) query(L,R,l,m,rt<<1); + if(R > m) query(L,R,m+1,r,rt<<1|1); +} +int main() +{ + int t,cas=1; + scanf("%d",&t); + while(t--) + { + printf("Case #%d:\n",cas++); + ll n,m; + scan_d(n); scan_d(m); + build(1,n,1); + while(m--) + { + char temp; + ll l,r; + scanf("%c",&temp); scan_d(l); scan_d(r); + if(temp == 'D') + { + update(l,r,1,n,1); + n+=(ll)(r-l+1); + } + else + { + ans = 0; + query(l,r,1,n,1); + printf("%I64d\n",ans); + } + } + } + return 0; +} diff --git a/HDOJ/4974_autoAC.cpp b/HDOJ/4974_autoAC.cpp new file mode 100644 index 0000000..0d24ce0 --- /dev/null +++ b/HDOJ/4974_autoAC.cpp @@ -0,0 +1,15 @@ +#include +#include +using namespace std; +int t,c=1,m,a,i,s,n; +int main() +{ + scanf("%d",&t); + while(t--) + { + scanf("%d",&n),s=0,m=0; + while(n--) + scanf("%d",&a),s+=a,m=max(m,a); + printf("Case #%d: %d\n",c++,max(m,(int)(s/2.0+0.5))); + } +} diff --git a/HDOJ/4975_autoAC.cpp b/HDOJ/4975_autoAC.cpp new file mode 100644 index 0000000..0c60f5b --- /dev/null +++ b/HDOJ/4975_autoAC.cpp @@ -0,0 +1,164 @@ +#include +#include +#include +#include +using namespace std; +const int inf=1<<29; +const int maxn=1100; +const int maxm=6e5; +struct Edge +{ + int u; + int v; + int f; + int nxt; + Edge(){} + Edge(int su,int sv,int sf,int snxt):u(su),v(sv),f(sf),nxt(snxt){} +}E[maxm]; +int n,m,row[510],col[510],sumr,sumc; +int e,st,des,head[maxn],level[maxn]; +bool vis[maxn]; +int q[maxn]; +void AddEdge(int u,int v,int f) +{ + E[e]=Edge(u,v,f,head[u]); + head[u]=e++; + E[e]=Edge(v,u,0,head[v]); + head[v]=e++; +} +void Build() +{ + e=st=0,des=n+m+1; + memset(head,-1,sizeof(head)); + for(int i=1;i<=n;i++) + for(int j=1;j<=m;j++) + AddEdge(i,n+j,9); + for(int i=1;i<=n;i++) + AddEdge(st,i,row[i]); + for(int i=1;i<=m;i++) + AddEdge(n+i,des,col[i]); +} +bool BFS() +{ + memset(level,0,sizeof(level)); + level[st]=1; + int pre=0,last=1; + q[pre]=st; + while(pre0) + { + E[i].f-=t; + E[i^1].f+=t; + f+=t; + if(f==maxf) + break; + } + else + level[E[i].v]=0; + } + return f; +} +int maxflow() +{ + int ans=0; + while(BFS()) + ans+=DFS(st,inf); + return ans; +} +bool dfs(int u,int f) +{ + vis[u]=1; + for(int &i=head[u];i!=-1;i=E[i].nxt) + if(E[i].f) + { + if(!vis[E[i].v]) + { + if(dfs(E[i].v,u)) + return true; + } + else if(E[i].v!=f) + return true; + } + vis[u]=0; + return false; +} +void solve(int sumr,int sumc) +{ + if(sumr!=sumc) + { + printf("So naive!\n"); + return; + } + Build(); + int ans=maxflow(); + if(ans!=sumc) + { + printf("So naive!\n"); + return; + } + memset(vis,0,sizeof(vis)); + bool is=false; + for(int i=1;i<=n;i++) + if(dfs(i,-1)) + is=true; + if(!is) + printf("So simple!\n"); + else + printf("So young!\n"); +} +inline bool read(int &n) +{ + int x = 0, tmp = 1; + char c = getchar(); + while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar(); + if(c == EOF) return false; + if(c == '-') c = getchar(), tmp = -1; + while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar(); + n = x*tmp; + return true; +} +int main() +{ + int T,cas=1; + scanf("%d",&T); + while(T--) + { + sumr=sumc=0; + scanf("%d%d",&n,&m); + for(int i=1;i<=n;i++) + { + read(row[i]); + sumr+=row[i]; + } + for(int i=1;i<=m;i++) + { + read(col[i]); + sumc+=col[i]; + } + printf("Case #%d: ",cas++); + solve(sumr,sumc); + } + return 0; +} diff --git a/HDOJ/4976_autoAC.cpp b/HDOJ/4976_autoAC.cpp new file mode 100644 index 0000000..4f9f353 --- /dev/null +++ b/HDOJ/4976_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define LL long long +#define lcm(a,b) (a*b/gcd(a,b)) +#define N 1500001 +int a[1100]; +int b[1100]; +int c[1100]; +int dp[1100]; +int main() +{ + int T; + int cas=0; + cin>>T; + int n; + while(T--) + { + cas++; + scanf("%d",&n); + int m=0; + for(int i=1; i<=n; i++) + { + scanf("%d",&a[i]); + m=max(a[i],m); + } + sort(a+1,a+n+1); + memset(c,0,sizeof(c)); + for(int i=1; i<=n; i++) + { + int j=a[i]; + while(c[j]&&j>0)j--; + if(j!=0)b[j]=a[i]-j; + c[j]=1; + } + memset(dp,0,sizeof(dp)); + int maxx=-1; + for(int i=1; i<=m; i++) + { + for(int j=i;j>=1;j--)dp[j]=dp[j-1]; + for(int j=0;j<=i;j++) + { + if(j>b[i]&&c[i])dp[j-b[i]-1]=max(dp[j-b[i]-1],dp[j]+1); + } + } + for(int j=0;j<=m;j++)maxx=max(maxx,dp[j]); + printf("Case #%d: %d\n",cas,maxx); + } + return 0; +} diff --git a/HDOJ/4977_autoAC.cpp b/HDOJ/4977_autoAC.cpp new file mode 100644 index 0000000..ca32f05 --- /dev/null +++ b/HDOJ/4977_autoAC.cpp @@ -0,0 +1,184 @@ +#include +#include +#include +#include +#include +#include +#include +#define next (i+1)%n +const double eps = 1e-8; +using namespace std; +const double PI = acos(-1); +const double sqrt3 = sqrt(3); +int dcmp(double x) +{ + if (x < -eps) return -1; + else if (x > eps) return 1; + else return 0; +} +double add(double a, double b) +{ + if (abs(a + b) < eps * (abs(a) + abs(b))) return 0; + return a + b; +} +struct Point +{ + double x,y; + Point() {} + Point(double x,double y) : x(x),y(y){} + Point operator + (Point p) {return Point(add(x, p.x),add(y, p.y)); } + Point operator - (Point p) {return Point(add(x, -p.x),add(y, -p.y)); } + Point operator * (double a) {return Point(x * a, y * a); } + Point operator / (double a) {return Point(x / a, y / a); } + bool operator < (const Point p) const {return dcmp(x - p.x) < 0 || dcmp(x - p.x) == 0 && dcmp(y - p.y)<0; } + bool operator == (const Point p) const {return dcmp(x - p.x) == 0 && dcmp(y - p.y) == 0; } + double dot(Point p) {return add(x * p.x, y * p.y); } + double det(Point p) {return add(x * p.y, -y * p.x); } + double length() {return sqrt(x*x + y*y); } + double Angle() {return atan2(y,x);} + Point Rotate(double rad) {return Point(add(x * cos(rad),- y * sin(rad)), add(x * sin(rad), y * cos(rad))); } + Point Normal() {return Point(-y / length(), x / length()); } +}; +typedef Point Vector; +int ConvexHull(Point* p,int n, Point* ch) +{ + sort(p,p+n); + int m = 0; + for (int i = 0; i < n ; i ++) + { + while (m > 1 && (ch[m-1] - ch[m-2]).det(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 &&(ch[m-1] - ch[m-2]).det(p[i] - ch[m-2]) <= 0) m--; + ch[m++] = p[i]; + } + if (n > 1) m--; + return m; +} +struct Circle +{ + Point c; + double r; + Circle(){} + Circle(Point c, double r): c(c),r(r){} + Point point(double a) + { + return Point(c.x + cos(a)*r, c.y + sin(a)*r); + } +}C; +int getLineCircleIntersection(Point p,Vector v,Circle C,Point sol[]) +{ + double t1,t2; + double a= v.x, b = p.x - C.c.x, c = v.y, d = p.y - C.c.y; + double e = a*a + c*c, f = 2*(a*b + c*d), g = b*b + d*d -C.r*C.r; + double delta = f*f - 4*e*g; + if (dcmp(delta) < 0) return 0; + if (dcmp(delta) == 0) + { + t1 = t2 = -f / (2 * e); sol[0] = sol[1] = p + v*t1; + return 1; + } + t1 = (-f - sqrt(delta)) / (2*e); sol[0] = p + v*t1; + t2 = (-f + sqrt(delta)) / (2*e); sol[1] = p + v*t2; + return 2; +} +double getAngle(double R, double l) +{ + return asin(R * sin( PI/6 ) / l) - PI/6; +} +bool OnSegment(Point p, Point a1, Point a2) +{ + return dcmp((a1 - p).det(a2 - p)) == 0 && dcmp((a1 - p).dot(a2 - p)) < 0; +} +int cnt; +vector > ans; +bool Section(Point a,Point b,double R) +{ + double aa = a.Angle(), bb = b.Angle(); + double da = getAngle(R, a.length()), db = getAngle(R, b.length()); + if (dcmp(aa-bb-PI) > 0) aa-=2*PI; + else if(dcmp(bb-aa-PI) > 0) bb-=2*PI; + double l=max(aa-da,bb-db), r = min(aa+da,bb+db); + if (dcmp(r-l)<0) + return false; + cnt++; + for(int i=0;i<6;i++) + { + l+=PI/3,r+=PI/3; + if(dcmp(l-PI)>=0) l -= 2*PI; + if(dcmp(r-PI)>=0) r -= 2*PI; + ans.push_back(make_pair(l,-1)); + ans.push_back(make_pair(r,1) ); + if(r < l) cnt--; + } + return true; +} +bool getSection(Point a, Point b, Circle C) +{ + double lena = a.length(),lenb = b.length(); + if (dcmp(lena-C.r) <= 0 && dcmp(lenb-C.r) <= 0) + return true; + Point sol[2]; + int n = getLineCircleIntersection(a,b-a,C,sol); + double R = C.r*sqrt3; + if (dcmp(lena-C.r) > 0 && dcmp(lenb - C.r) > 0) + { + if (n == 0) return Section(a,b,R); + bool judge0 = OnSegment(sol[0],a,b); + bool judge1 = OnSegment(sol[1],a,b); + if (judge0 || judge1) + return Section(a,sol[0],R) && Section(sol[1],b,R); + return Section(a, b, R); + } + if (dcmp(lena - C.r) > 0) + return Section(a,sol[0],R); + return Section(sol[1],b,R); +} +Point P[2000],Hull[2000]; +int main() +{ + int T; + scanf("%d",&T); + for (int kase = 1; kase <= T; kase ++) + { + int m,r; + Circle C = Circle(Point(0,0),0); + scanf("%d%lf", &m, &C.r); + const double R = C.r*sqrt3; + bool flag = true; + for (int i = 0; i < m; i++) + scanf("%lf%lf", &P[i].x, &P[i].y); + int n = ConvexHull(P, m, Hull); + ans.clear(); + cnt = 0; + for (int i = 0; i < n && flag; i++) + { + if (dcmp(Hull[i].length()-R) > 0 || dcmp(Hull[next].length()-R) > 0) + { + flag = false; + break; + } + flag = getSection(Hull[i],Hull[next],C); + } + if (flag) + { + sort(ans.begin(), ans.end()); + int now = 0,h = 0; + for (int i = 0; i < ans.size(); i++) + { + now -= ans[i].second; + if (h == cnt) + break; + h = max(h, now); + } + if (h!=cnt) + flag = false; + } + printf("Case #%d: ", kase); + if (flag) printf("Succeeded.\n"); + else printf("Failed.\n"); + } +} diff --git a/HDOJ/4978_autoAC.cpp b/HDOJ/4978_autoAC.cpp new file mode 100644 index 0000000..31b5b6d --- /dev/null +++ b/HDOJ/4978_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include +using namespace std; +#define offset 100 +#define eps 1e-8 +#define PI acos(-1.0) +#define MAXN 105 +#define zero(x) (((x)>0? (x):-(x))eps? 1:((x)<-eps? 2:0)) +struct point +{ + double x; + double y; + point(const double &x = 0, const double &y = 0):x(x), y(y) {} + void in() + { + scanf("%lf %lf", &x, &y); + } + void out()const + { + printf("%.2f %.2f\n",x, y); + } +}; +double xmult(point p1,point p2,point p0) +{ + return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y); +} +double dis(point a, point b) +{ + return sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) ) ; +} +point p1,p2; +int graham_cp(const void* a,const void* b) +{ + double ret=xmult(*((point*)a),*((point*)b),p1); + return zero(ret)?(xmult(*((point*)a),*((point*)b),p2)>0?1:-1):(ret>0?1:-1); +} +void _graham(int n,point* p,int& s,point* ch) +{ + int i,k=0; + for (p1=p2=p[0],i=1; ieps||(zero(p1.y-p[i].y)&&p1.x>p[i].x)) + p1=p[k=i]; + p2.x/=n,p2.y/=n; + p[k]=p[0],p[0]=p1; + qsort(p+1,n-1,sizeof(point),graham_cp); + for (ch[0]=p[0],ch[1]=p[1],ch[2]=p[2],s=i=3; i2&&xmult(ch[s-2],p[i],ch[s-1])<-eps; s--); +} +int graham(int n,point* p,point* convex,int maxsize=1,int dir=1) +{ + point* temp=new point[n]; + int s,i; + _graham(n,p,s,temp); + for (convex[0]=temp[0],n=1,i=(dir?1:(s-1)); dir?(i2) + { + int num = graham(N,P,c); + for(int i = 0; i < num-1; i ++) + { + ans+=dis(c[i],c[i+1]); + } + ans+=dis(c[0],c[num-1]); + } + else ans = dis(P[0],P[1])*2; + printf("Case #%d: %.4lf\n",cas++,ans/(PI*D)); + } +} diff --git a/HDOJ/4979_autoAC.cpp b/HDOJ/4979_autoAC.cpp new file mode 100644 index 0000000..c419519 --- /dev/null +++ b/HDOJ/4979_autoAC.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int ans[8][8][8]={ + { + {1} + }, + { + {2}, + {1,1} + }, + { + {3}, + {2,3}, + {1,1,1} + }, + { + {4}, + {2,6}, + {2,3,4}, + {1,1,1,1} + }, + { + {5}, + {3,10}, + {2,4,10}, + {2,3,4,5}, + {1,1,1,1,1} + }, + { + {6}, + {3,15}, + {2,6,20}, + {2,3,6,15}, + {2,3,4,5,6}, + {1,1,1,1,1,1} + }, + { + {7}, + {4,21}, + {3,7,35}, + {2,5,12,35}, + {2,3,5,9,21}, + {2,3,4,5,6,7}, + {1,1,1,1,1,1,1} + }, + { + {8}, + {4,28}, + {3,11,56}, + {2,6,14,70}, + {2,4,8,20,56}, + {2,3,4,7,12,28}, + {2,3,4,5,6,7,8}, + {1,1,1,1,1,1,1,1} + } +}; +int main() +{ + int n,m,r,T,tt=0; + scanf("%d",&T); + while(T--) + { + scanf("%d%d%d",&n,&m,&r); + printf("Case #%d: %d\n",++tt,ans[n-1][m-1][r-1]); + } + return 0; +} diff --git a/HDOJ/4980_autoAC.cpp b/HDOJ/4980_autoAC.cpp new file mode 100644 index 0000000..5fdefa7 --- /dev/null +++ b/HDOJ/4980_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#define snuke(it,x) for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); ++ it) +const int N = 500 + 5; +const int D = 5; +const int INF = 0x3f3f3f3f; +std::vector > edges[N]; +int n,drop_cost,dp[N][D],tmp[D][D]; +inline void toMin(int &a,int b) { + if (a>b) a = b; +} +void dfs(int u,int fa) { + dp[u][0] = 0; + snuke(it,edges[u]) { + int v = it->first; + int w = it->second; + if (v==fa) continue; + dfs(v,u); + for (int j = 0; j < D; ++ j) { + for (int k = 0; k < D; ++ k) { + tmp[j][k] = INF; + } + } + for (int j = 0; j < D; ++ j) { + for (int k = 1; j+k < D; ++ k) { + toMin(tmp[j+k][std::min(j,k)],dp[u][j]+dp[v][k]+k*w); + } + } + for (int j = D-1; j >= 2; -- j) { + for (int k = j>>1; k >= 1; -- k) { + toMin(tmp[j-2][k-1],tmp[j][k]+drop_cost); + } + } + for (int j = D-1; j >= 0; -- j) { + dp[u][j] = INF; + if (j!=D-1) toMin(dp[u][j],dp[u][j+1]+drop_cost); + for (int k = 0; k < D; ++ k) { + toMin(dp[u][j],tmp[j][k]); + } + } + } + toMin(dp[u][1],dp[u][0]); +} +inline void read(int &x) { + char c; bool sign = false; + for (c = getchar(); c<'0' || c>'9'; c = getchar()) if (c=='-') sign = true; + for (x = 0; c>='0' && c<='9'; c = getchar()) x = x*10+c-'0'; + sign && (x=-x); +} +int main() { + int cas,ca = 0; + read(cas); + while (cas--) { + read(n); read(drop_cost); + std::fill(edges,edges+n,std::vector >()); + for (int i = 0; i < n-1; ++ i) { + int a,b,c; + read(a),read(b),read(c); + edges[a].push_back(std::make_pair(b,c)); + edges[b].push_back(std::make_pair(a,c)); + } + memset(dp,INF,sizeof(dp)); + dfs(0,-1); + printf("Case #%d: ",++ca); + if (n==1) { + puts("0"); + continue; + } + int answer = INF; + for (int i = 0; i < D; ++ i) { + toMin(answer,dp[0][i]+i*drop_cost); + } + printf("%d\n",answer); + } + return 0; +} diff --git a/HDOJ/4981_autoAC.cpp b/HDOJ/4981_autoAC.cpp new file mode 100644 index 0000000..0975021 --- /dev/null +++ b/HDOJ/4981_autoAC.cpp @@ -0,0 +1,24 @@ +#include +#include +#include +using namespace std; +int main() +{ + int N,array[1050]; + while(~scanf("%d",&N)) + { + int sum = 0; + for(int i = 0; i < N; i++) + { + scanf("%d",&array[i]); + sum += array[i]; + } + sort(array,array+N); + double aver = (double)sum/N; + if(aver >= (double)array[(N-1)/2]) + printf("NO\n"); + else + printf("YES\n"); + } + return 0; +} diff --git a/HDOJ/4982_autoAC.cpp b/HDOJ/4982_autoAC.cpp new file mode 100644 index 0000000..d344409 --- /dev/null +++ b/HDOJ/4982_autoAC.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define INF 2000000000 +using namespace std; +typedef long long ll; +const int MAX_E=10000; +const int MAX_N=1005; +const int MAX_K=3000; +const int MAXN=10010; +bool judge(int sum,int y,int k) +{ + int mid1=(k-1)*k/2; + int mid2=sum-mid1; + if(mid2<=k-1) return false; + if(y>k-1&&y!=mid2) return true; + if(y<=k-1){ + if(k-y<=mid2-(k+1)) return true; + else return false; + } + if(y==mid2){ + if(mid2-(k-1)>=3) return true; + else return false; + } +} +int main() +{ + int n,k,T,mm; + bool flag; + while(scanf("%d%d",&n,&k)!=EOF){ + int c1=(int)sqrt((double)k*(k-1)/2); + int c2=(int)sqrt((double)n); + flag=0; + for(int i=c1;i<=c2;i++){ + if((k*(k-1)/2<=i*i)&&(i*i<=n-1)&&judge(i*i,n-i*i,k-1)){ + flag=1; + break; + } + } + if(flag==1) printf("YES\n"); + else printf("NO\n"); + } + return 0; +} diff --git a/HDOJ/4983_autoAC.cpp b/HDOJ/4983_autoAC.cpp new file mode 100644 index 0000000..af0a5a9 --- /dev/null +++ b/HDOJ/4983_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#define mod 1000000007 +#define LL __int64 +using namespace std; +int prim[81000],tot; +int u[1000005]; +bool vis[1000005]; +void init(void){ + int i; + for(i=1;i<=1000000;i++) u[i]=i; + for(i=2;i<=1000000;i++){ + if(!vis[i]){ + for(int j=i;j<=1000000;j+=i){ + u[j]=u[j]/i*(i-1); + vis[j]=1; + } + prim[tot++]=i; + } + } +} +int get(int n){ + int i,s,q; + q=n; + s=n; + for(i=0;i2){ printf("0\n"); + continue; + } + if(k==2){ + printf("1\n"); + continue; + } + for(i=1;(LL)i*i<=n;i++){ + if(n%i==0){ + if(i<=1000000) + q=u[i]; + else q=get(i); + if(n/i<=1000000) q=q*u[n/i]; + else q=q*get(n/i); + q=q%mod; + if((LL)i*i!=n) + q=(q*2)%mod; + s+=q; + s%=mod; + } + } + printf("%d\n",s); + } +} diff --git a/HDOJ/4984_autoAC.cpp b/HDOJ/4984_autoAC.cpp new file mode 100644 index 0000000..4005e85 --- /dev/null +++ b/HDOJ/4984_autoAC.cpp @@ -0,0 +1,117 @@ +#include +#include +#include +using namespace std ; +#define REP( i , a , b ) for ( int i = ( a ) ; i < ( b ) ; ++ i ) +#define FOR( i , a , b ) for ( int i = ( a ) ; i <= ( b ) ; ++ i ) +#define REV( i , a , b ) for ( int i = ( a ) ; i >= ( b ) ; -- i ) +#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next ) +#define CLR( a , x ) memset ( a , x , sizeof a ) +typedef long long LL ; +const int MAXN = 55 ; +const int MAXE = 205 ; +const double INF = 1e10 ; +const double eps = 1e-8 ; +struct Edge { + int v ; + double c ; + Edge* next ; +} E[MAXE] , *H[MAXN] , *cur ; +struct Line { + int x , y , a , b ; + double v ; + void input () { + scanf ( "%d%d%d%d" , &x , &y , &a , &b ) ; + } + bool operator < ( const Line& p ) const { + return v > p.v ; + } +} L[MAXE] ; +int n , m , t ; +int p[MAXN] ; +double f[MAXN] ; +double a[10005] ; +int cnt ; +double st , ed , ans ; +int sgn ( double x ) { + return ( x > eps ) - ( x < -eps ) ; +} +void clear () { + cur = E ; + CLR ( H , 0 ) ; + FOR ( i , 1 , n ) { + p[i] = i ; + f[i] = INF ; + } +} +void addedge ( int u , int v , double c ) { + cur -> v = v ; + cur -> c = c ; + cur -> next = H[u] ; + H[u] = cur ++ ; +} +int find ( int x ) { + return p[x] == x ? x : ( p[x] = find ( p[x] ) ) ; +} +void kruskal () { + sort ( L , L + m ) ; + int cnt = 1 ; + REP ( i , 0 , m ) { + int x = find ( L[i].x ) ; + int y = find ( L[i].y ) ; + if ( x != y ) { + p[x] = y ; + addedge ( L[i].x , L[i].y , L[i].v ) ; + addedge ( L[i].y , L[i].x , L[i].v ) ; + if ( ++ cnt == n ) break ; + } + } +} +void dfs ( int u , int fa ) { + travel ( e , H , u ) { + int v = e -> v ; + if ( v == fa ) continue ; + f[v] = min ( f[u] , e -> c ) ; + dfs ( v , u ) ; + } +} +int unique ( int n ) { + int cnt = 1 ; + sort ( a + 1 , a + n + 1 ) ; + FOR ( i , 2 , n ) if ( sgn ( a[i] - a[cnt] ) ) a[++ cnt] = a[i] ; + return cnt ; +} +void solve () { + ans = 0 ; + cnt = 0 ; + scanf ( "%d%d%d" , &n , &m , &t ) ; + REP ( i , 0 , m ) { + L[i].input () ; + REP ( j , 0 , i ) { + if ( L[i].b == L[j].b ) continue ; + a[++ cnt] = ( double ) ( L[i].a - L[j].a ) / ( L[j].b - L[i].b ) ; + } + } + a[++ cnt] = t ; + cnt = unique ( cnt ) ; + st = 0 ; + FOR ( i , 1 , cnt ) { + if ( a[i] < 0 ) continue ; + if ( a[i] > t ) break ; + ed = a[i] ; + double mid = ( st + ed ) / 2 ; + REP ( j , 0 , m ) L[j].v = L[j].a + L[j].b * mid ; + clear () ; + kruskal () ; + dfs ( 1 , 0 ) ; + FOR ( j , 2 , n ) ans += f[j] * ( ed - st ) ; + st = ed ; + } + printf ( "%.3f\n" , ans / t ) ; +} +int main () { + int T ; + scanf ( "%d" , &T ) ; + while ( T -- ) solve () ; + return 0 ; +} diff --git a/HDOJ/4985_autoAC.cpp b/HDOJ/4985_autoAC.cpp new file mode 100644 index 0000000..83e1dd9 --- /dev/null +++ b/HDOJ/4985_autoAC.cpp @@ -0,0 +1,29 @@ +#include +#include +#include +#include +using namespace std; +const int N = 100005; +int n, a[N], vis[N]; +int main() { + while (~scanf("%d", &n)) { + memset(vis, 0, sizeof(vis)); + for (int i = 1; i <= n; i++) + scanf("%d", &a[i]); + for (int i = 1; i <= n; i++) { + if (vis[i]) continue; + int t = i; + printf("(%d", t); + vis[t] = 1; + t = a[t]; + while (vis[t] == 0) { + vis[t] = 1; + printf(" %d", t); + t = a[t]; + } + printf(")"); + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/4986_autoAC.cpp b/HDOJ/4986_autoAC.cpp new file mode 100644 index 0000000..b1e7780 --- /dev/null +++ b/HDOJ/4986_autoAC.cpp @@ -0,0 +1,19 @@ +#include +#include +#include +#include +using namespace std ; +double dp[1000005] ; +int main() +{ + dp[1]=1.0 ; + for(int i=2 ;i<=1000000 ;i++) + dp[i]=dp[i-1]+1.0/i ; + int n ; + while(~scanf("%d",&n)) + { + if(n>1000000)printf("%.4f\n",0.57721566490153286060651209+log(n+1)) ; + else printf("%.4f\n",dp[n]) ; + } + return 0 ; +} diff --git a/HDOJ/4987_autoAC.cpp b/HDOJ/4987_autoAC.cpp new file mode 100644 index 0000000..1556ef0 --- /dev/null +++ b/HDOJ/4987_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +const double eps=0.0000000000001; +double dp[1000005]; +int main() +{ + int n,m; + while(~scanf("%d%d",&m,&n)) + { + int flag=1; + memset(dp,0,sizeof(dp)); + dp[0]=1.0; + dp[1]=1.0/m; + for(int i=2;i<=n;i++) + { + dp[i]+=dp[i-1]*(m+1)/m; + if(i-1-m>=0) + dp[i]-=dp[i-1-m]/m; + if(fabs(dp[i]-dp[i-1]) +#include +#include +#include +using namespace std; +#define INF (~0U>>1) +#define lson l,m,o<<1 +#define rson m+1,r,o<<1|1 +#define maxn 100010 +typedef __int64 ll; +struct node{ + int v; + int sz; + int s; + node *p; + node *ch[2]; + node(){ + sz=v=0; + s=-1; + p=ch[0]=ch[1]=this; + } + bool cmp(int s) + { + return this->sp=this; + } +}Tnull,*null=&Tnull; +node *newnode(int v) +{ + node *u=(node*)malloc(sizeof(node)); + u->sz=1; + u->s=rand(); + u->v=v; + u->ch[0]=u->ch[1]=null; + return u; +} +void pushup(node *o) +{ + o->sz=o->ch[0]->sz+o->ch[1]->sz+1; +} +void rot(node *o,int d) +{ + node *k=o->ch[d]; + o->addc(k->ch[d^1],d); + o->p->addc(k,o->p->cd(o)); + k->addc(o,d^1); + pushup(o); + pushup(k); +} +void Insert(node *o,node *pre,int v,int dd) +{ + if(o==null){ + pre->addc(newnode(v),dd); + return; + } + int d; + if(v>=o->v){ + d=1; + Insert(o->ch[1],o,v,1); + } + else { + d=0; + Insert(o->ch[0],o,v,0); + } + if(o->cmp(o->ch[d]->s))rot(o,d); + else pushup(o); +} +void Delete(node *o,int v) +{ + if(o==null)return; + if(v==o->v){ + while(o->ch[0]!=null&&o->ch[1]!=null) + { + int d=o->ch[0]->cmp(o->ch[1]->s); + rot(o,d); + --o->p->sz; + } + node *k; + o->ch[0]==null? k=o->ch[1]:k=o->ch[0]; + o->p->addc(k,o->p->cd(o)); + free(o); + return; + } + v>o->v ? Delete(o->ch[1],v) : Delete(o->ch[0],v); + pushup(o); +} +int Find(node *o,int v,int vis) +{ + if(o==null)return 0; + int ax=0; + if(v>o->v){ + if(!vis)ax+=o->ch[0]->sz+1; + ax+=Find(o->ch[1],v,vis); + } + else { + if(vis)ax+=o->ch[1]->sz+1; + ax+=Find(o->ch[0],v,vis); + } + return ax; +} +void Free(node *o) +{ + if(o==null)return; + Free(o->ch[0]); + Free(o->ch[1]); + free(o); +} +node *tree[maxn]; +int a[maxn]; +int b[maxn]; +int p[maxn]; +int pa[maxn]; +int pb[maxn]; +int n; +int bit(int x) +{ + return x&(-x); +} +void buildST() +{ + for(int i=0;ich[0]=tree[i]->ch[1]=null; + } +} +void updateST1(int p,int v) +{ + while(pch[1],tree[p],v,1); + p+=bit(p+1); + } +} +void updateST2(int p,int v) +{ + while(pch[1],v); + p+=bit(p+1); + } +} +int queryST(int p,int v1,int v2) +{ + int ax=0; + while(p>=0) + { + ax+=Find(tree[p]->ch[1],v1,0) + Find(tree[p]->ch[1],v2,1); + p-=bit(p+1); + } + return ax; +} +void FreeST() +{ + for(int i=0;i=0) + { + ans+=sum[x]; + x-=bit(x+1); + } + return ans; +} +int main() +{ + int i,Q; + while(scanf("%d",&n)!=EOF) + { + for(i=0;iy)swap(x,y); + if(p[x]>p[y]){ + y-x==1 ? temp=0 : temp=queryST(y,p[y],p[x])-queryST(x,p[y],p[x]); + ans+=((temp-y+x+1)<<1)-1; + } + else { + y-x==1 ? temp=0 : temp=queryST(y,p[x],p[y])-queryST(x,p[x],p[y]); + ans+=1+((y-x-1-temp)<<1); + } + updateST1(x,p[y]); + updateST1(y,p[x]); + swap(p[x],p[y]); + } + } + FreeST(); + } + return 0; +} diff --git a/HDOJ/4989_autoAC.cpp b/HDOJ/4989_autoAC.cpp new file mode 100644 index 0000000..ed1631d --- /dev/null +++ b/HDOJ/4989_autoAC.cpp @@ -0,0 +1,30 @@ +#include +#include +#define ll long long +#define maxn 100+5 +using namespace std; +ll a[maxn]; +mapmapp; +int main() +{ + int n; + while(cin>>n) + { + mapp.clear(); + ll sum=0; + for(int i=0;i>a[i]; + for(int j=0;j +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define INF 1000000000 +#define ll long long +#define min3(a,b,c) min(a,min(b,c)) +#define max3(a,b,c) max(a,max(b,c)) +#define MAXN 100010 +using namespace std; +ll a,b,c,d; +ll n,m; +ll fun(ll a,ll b,ll c,ll d,ll n){ + ll ta=1; + ll tb=0; + ll tc=0; + ll td=1; + while(n){ + ll aa,bb,cc,dd; + if(n&1){ + aa=a*ta+b*tc; + bb=a*tb+b*td; + cc=c*ta+d*tc; + dd=c*tb+d*td; + ta=aa; tb=bb; tc=cc; td=dd; + ta%=m; tb%=m; tc%=m; td%=m; + } + aa=a*a+b*c; + bb=a*b+b*d; + cc=c*a+d*c; + dd=c*b+d*d; + a=aa; b=bb; c=cc; d=dd; + a%=m; b%=m; c%=m; d%=m; + n>>=1; + } + return tb; +} +int main(){ + while(~scanf("%I64d%I64d",&n,&m)){ + ll nn=(n+1)/2; + ll ans=fun(4,1,0,1,nn); + if(n%2==0)ans*=2; + ans%=m; + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/4991_autoAC.cpp b/HDOJ/4991_autoAC.cpp new file mode 100644 index 0000000..0a0dc89 --- /dev/null +++ b/HDOJ/4991_autoAC.cpp @@ -0,0 +1,52 @@ +#include +#include +#include +#include +using namespace std; +typedef int ll; +const int MAX_N = 10005; +const ll MOD = 123456789; +ll C[105][MAX_N]; +ll A[MAX_N],B[MAX_N]; +int len; +int lowbit(int x){ + return x&(-x); +} +void add(int x,ll value, int floor){ + while(x<=len){ + C[floor][x]=(C[floor][x]+value)%MOD; + x+=lowbit(x); + } +} +ll sum(int x, int floor){ + ll ans=0; + while(x>0){ + ans=(ans+C[floor][x])%MOD; + x-=lowbit(x); + } + return ans; + } +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m)==2){ + for(int i=0; i +#include +#include +#include +using namespace std; +typedef __int64 LL; +const int MAXN = 1005; +int prim[MAXN], nprm; +bool vis[MAXN]; +int n, m; +void init_prim() +{ + for (int i = 2; i< MAXN; ++i) + { + if (!vis[i]) prim[nprm++] = i; + for (int j = 0; j< nprm && prim[j]&i < MAXN; ++i) + { + vis[prim[j]*i] = 1; + if (i % prim[j] == 0) break; + } + } +} +int Euler(int x) +{ + int res = x; + for (int i = 0, k; i< nprm ; ++i) + { + k = prim[i]; + if (k * k > x) break; + if (x % k == 0) + { + res = res/k*(k-1); + while (x%k==0) x/=k; + } + } + if (x!=1) res = res/x*(x-1); + return res; +} +int nfen, fen[100][2]; +void m_divide(int x) +{ + nfen = 0; + for (int i = 0, k; i< nprm ; ++i) + { + k = prim[i]; + if (k * k > x) break; + if (x % k == 0) + { + fen[nfen][0] = k; + fen[nfen][1] = 0; + while (x%k==0) x/=k, ++fen[nfen][1]; + ++nfen; + } + } + if (x!=1) fen[nfen][0]=x, fen[nfen++][1]=1; +} +LL mpow(LL a, int b, LL mod) +{ + LL res = 1LL; + while (b) + { + if (b&1) res = res*a%mod; + a = a*a%mod; + b >>= 1; + } + return res; +} +int caonima = 0; +LL ri; +void dfs(int idx, LL all) +{ + if (caonima) return; + if (idx == nfen) + { + if (all == 1LL || all == m) return; + if (mpow(ri, all, n) == 1LL) + caonima = 1; + return; + } + for (int i = 0; i<=fen[idx][1]; ++i) + { + dfs(idx+1, all); + all *= fen[idx][0]; + } +} +int check(LL r) +{ + LL res = r; + if (mpow(r, m, n) != 1LL) return 0; + caonima = 0; + ri = res; + dfs(0, 1); + if (caonima) return 0; + return 1; +} +int gcd(int a, int b) +{ + return b==0?a:gcd(b,a%b); +} +int opt[1000000], cnt; +void solve() +{ + m = Euler(n); + m_divide(m); + int ff = 0; + for (int i = 2; i< n; ++i) + { + if (check(i)) + { + ff = i; + break; + } + } + if (!ff) + { + printf("-1\n"); + return; + } + cnt = 0; + opt[cnt++] = ff; + LL res = ff; + res = res*ff%n; + for (int i = 2; i< m; ++i, res = res*ff%n) + { + if (gcd(i, m) == 1) + { + opt[cnt++] = res; + } + } + sort(opt, opt+cnt); + printf("%d", opt[0]); + for (int i = 1; i< cnt; ++i) + { + printf(" %d", opt[i]); + } + puts(""); +} +int main() +{ + init_prim(); + while (scanf("%d", &n) != EOF) + { + if (n==2) puts("1"); + else if (n==4) puts("3"); + else + { + int p = n, cc = 0; + if (n%2==0) n>>=1; + for (int i = 0, k; i n) break; + if (n % k == 0) + { + if (++cc > 1) break; + while (n % k==0) n /= k; + } + } + if (n!=1) ++cc; + if (cc!=1) puts("-1"); + else + { + n = p; + solve(); + } + } + } + return 0; +} diff --git a/HDOJ/4993_autoAC.cpp b/HDOJ/4993_autoAC.cpp new file mode 100644 index 0000000..8f8a5df --- /dev/null +++ b/HDOJ/4993_autoAC.cpp @@ -0,0 +1,19 @@ +#include +int main () +{ + int t ,a ,b ,c ,Ans ,x ,y; + scanf("%d" ,&t); + while(t--) + { + scanf("%d %d %d" ,&a ,&b ,&c); + x = 1 ,Ans = 0; + while(1) + { + if(x * a >= c) break; + if((c - x * a) % b == 0) Ans ++; + x ++; + } + printf("%d\n" ,Ans); + } + return 0; +} diff --git a/HDOJ/4994_autoAC.cpp b/HDOJ/4994_autoAC.cpp new file mode 100644 index 0000000..d811c87 --- /dev/null +++ b/HDOJ/4994_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long long LL; +typedef unsigned long long LLU; +const double PI=acos(-1.0); +using namespace std; +int main() +{ + int t; + cin>>t; + while(t--) + { + int n, a[1111], cnt=0; + cin>>n; + for(int i=0; i>a[i]; + for(int i=0; i +#include +#include +#include +using namespace std; +const int N = 1e5 + 5; +typedef long long ll; +map vis; +int T, n, m, k; +struct Node { + ll x; + double v; + int id; +}node[N]; +int cmp (const Node &a, const Node &b) { + return a.x < b.x; +} +double solve () { + double ans = 0; + vis.clear(); + sort (node, node + n, cmp); + for (int i = 0; i < n; i++) + vis[node[i].id] = i; + int pos, tmp; + int num; + for (int i = 0; i < m; i++) { + scanf ("%d", &num); + pos = vis[num - 1]; + int p1 = pos - 1; + int p2 = pos + 1; + double sum = 0; + tmp = 0; + while (tmp < k) { + if (p1 == -1) + sum += node[p2++].v; + else if (p2 == n) + sum += node[p1--].v; + else { + if (node[pos].x - node[p1].x < node[p2].x - node[pos].x) + sum += node[p1--].v; + else if (node[pos].x - node[p1].x > node[p2].x - node[pos].x) + sum += node[p2++].v; + else if (node[p1].id < node[p2].id) + sum += node[p1--].v; + else + sum += node[p2++].v; + } + tmp++; + } + ans += sum / k; + node[pos].v = sum / k; + } + return ans; +} +int main () { + scanf ("%d", &T); + while (T--) { + scanf ("%d%d%d", &n, &m, &k); + for (int i = 0; i < n; i++) { + scanf ("%I64d%lf", &node[i].x, &node[i].v); + node[i].id = i; + } + printf ("%.6lf\n", solve()); + } + return 0; +} diff --git a/HDOJ/4996_autoAC.cpp b/HDOJ/4996_autoAC.cpp new file mode 100644 index 0000000..cfd856f --- /dev/null +++ b/HDOJ/4996_autoAC.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define RD(x) scanf("%d",&x) +#define RD2(x,y) scanf("%d%d",&x,&y) +#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z) +#define clr0(x) memset(x,0,sizeof(x)) +typedef long long LL; +const int maxn = 1<<20; +int n,k; +LL f[20][20],dp[maxn],tmp[maxn]; +int cal(int x) +{ + int ans = 0; + for(int i = 0;i < 20;++i) + if((1<= k) + c[tot]++; + tot++; + } + } + c[tot++] = k; + for(int l = 0;l < tot;++l){ + if(c[l] > k){ + c[l] = k; + break; + } + } + for(int l = 0;l < tot;++l){ + st |= (1< +#include +#include +#include +using namespace std; +const int MAX_N = 10; +const int MAX_S = 1 << MAX_N; +const int Mod = (int)1e9 + 7; +int n, m; +bool edge[MAX_N][MAX_N]; +int cntEdge[MAX_S][MAX_S]; +long long connected[MAX_S]; +long long biconnected[MAX_S]; +long long expand[MAX_S][MAX_S]; +int main() { + #ifdef LOCAL_JUDGE + freopen("in.txt", "r", stdin); + #endif + int T; + scanf("%d", &T); + for (int cas = 1; cas <= T; cas++) { + scanf("%d %d", &n, &m); + memset(edge, true, sizeof(edge)); + for (int i = 1; i <= m; i++) { + int a, b; + scanf("%d %d", &a, &b); + a--; + b--; + edge[a][b] = false; + edge[b][a] = false; + } + for (int i = 0; i < n; i++) { + edge[i][i] = false; + } + int cntState = 1 << n; + for (int i = 0; i < cntState; i++) { + for (int j = 0; j < cntState; j++) { + if (i == j || (i & j) == 0) { + int &ref = cntEdge[i][j]; + ref = 0; + for (int x = 0; x < n; x++) { + if ((i >> x) & 1) { + int low = (i == j) ? x + 1 : 0; + for (int y = low; y < n; y++) { + if ((j >> y) & 1) { + ref += edge[x][y]; + } + } + } + } + } + } + } + connected[0] = 1; + biconnected[0] = 1; + for (int mask = 1; mask < cntState; mask++) { + int lowbit = mask & -mask; + { + long long &ref = connected[mask]; + ref = 1ll << cntEdge[mask][mask]; + for (int subset = mask ^ lowbit; subset; subset = (subset - 1) & (mask ^ lowbit)) { + ref -= connected[mask ^ subset] * (1ll << cntEdge[subset][subset]); + } + } + { + for (int target = mask ^ lowbit; target; target = (target - 1) & (mask ^ lowbit)) { + int source = mask ^ target; + int _lowbit = target & -target; + long long &ref = expand[mask][source]; + ref = 0; + for (int subset = target ^ _lowbit; ; subset = (subset - 1) & (target ^ _lowbit)) { + int set = target ^ subset; + ref += connected[set] * cntEdge[set][source] * expand[mask ^ set][source]; + if (subset == 0) { + break; + } + } + } + expand[mask][mask] = 1; + } + { + long long &ref = biconnected[mask]; + ref = connected[mask]; + for (int subset = mask ^ lowbit; subset; subset = (subset - 1) & (mask ^ lowbit)) { + ref -= biconnected[mask ^ subset] * expand[mask][mask ^ subset]; + } + } + } + int ans = biconnected[cntState - 1] % Mod; + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4998_autoAC.cpp b/HDOJ/4998_autoAC.cpp new file mode 100644 index 0000000..e69641e --- /dev/null +++ b/HDOJ/4998_autoAC.cpp @@ -0,0 +1,89 @@ +#include +#include +using namespace std; +#define PI acos(-1.0) +struct Point { + double x, y; + Point(double x = 0, double y = 0) : x(x), y(y) {} +}; +int n; +Point p[15]; +double rad[15]; +typedef Point Vector; +Vector operator + (Vector A, Vector B) { return Vector(A.x + B.x, A.y + B.y); } +Vector operator - (Point A, Point B) { return Vector(A.x - B.x, A.y - B.y); } +Vector operator * (Vector A, double p) { return Vector(A.x * p, A.y * p); } +Vector operator / (Vector A, double p) { return Vector(A.x / p, A.y / p); } +bool operator < (const Point& a, const Point& b) { + return a.x < b.x || (a.x == b.x && a.y < b.y); +} +const double eps = 1e-10; +int dcmp(double x) { + if(fabs(x) < eps) return 0; + else return x < 0 ? -1 : 1; +} +bool operator == (const Point& a, const Point& b) { + return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0; +} +double Dot(Vector A, Vector B) { return A.x * B.x + A.y * B.y; } +double Length(Vector A) { return sqrt(Dot(A, A)); } +double Angle(Vector A, Vector B) { return acos(Dot(A, B) / Length(A) / Length(B)); } +double Cross(Vector A, Vector B) { return A.x * B.y - A.y * B.x; } +Vector Rotate(Vector A, double rad) { + return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad)); +} +Vector Normal(Vector A) { + double L = Length(A); + return Vector(-A.y / L, A.x / L); +} +Point GetLineIntersection(Point P, Vector v, Point Q, Vector w) { + Vector u = P - Q; + double t = Cross(w, u) / Cross(v, w); + return P + v * t; +} +Vector Rotate_Point(Vector A) { + for(int i = 0; i < n; i++) { + A = p[i] + Rotate(A - p[i], rad[i]); + } + return A; +} +Vector Get_Mid_Point(Point A, Point B) { + return Vector((A.x + B.x) / 2, (A.y + B.y) / 2); +} +void Get_Ans() { + Point f1[2], f2[2], mid[2], vec[2]; + f1[0].x = -1; + f1[0].y = -1; + f1[1].x = -10; + f1[1].y = -50; + for(int i = 0; i < 2; i++) { + f2[i] = Rotate_Point(f1[i]); + mid[i] = Get_Mid_Point(f1[i], f2[i]); + vec[i] = Normal(f1[i] - f2[i]); + } + Point ans = GetLineIntersection(mid[0], vec[0], mid[1], vec[1]); + double ansp = Angle(f1[0] - ans, f2[0] - ans); + if(Cross(f1[0] - ans, f2[0] - ans) < 0) + ansp = 2 * PI - ansp; + if(dcmp(ans.x) == 0) ans.x = 0; + if(dcmp(ans.y) == 0) ans.y = 0; + printf("%.10lf %.10lf %.10lf\n", ans.x, ans.y, ansp); +} +int main() +{ + int T; + scanf("%d", &T); + while(T--) { + scanf("%d", &n); + for(int i = 0; i < n; i++) { + scanf("%lf%lf%lf", &p[i].x, &p[i].y, &rad[i]); + if(dcmp(rad[i] - 2 * PI) == 0 || dcmp(rad[i]) == 0) { + rad[i] = 0; + n--; + i--; + } + } + Get_Ans(); + } + return 0; +} diff --git a/HDOJ/4999_autoAC.cpp b/HDOJ/4999_autoAC.cpp new file mode 100644 index 0000000..74ea9cf --- /dev/null +++ b/HDOJ/4999_autoAC.cpp @@ -0,0 +1,284 @@ +#pragma comment(linker, "/STACK:102400000,102400000") +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#ifdef _WIN32 +#define i64 __int64 +#define out64 "%I64d\n" +#define in64 "%I64d" +#else +#define i64 long long +#define out64 "%lld\n" +#define in64 "%lld" +#endif +/************ for topcoder by zz1215 *******************/ +#define foreach(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++) +#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++) +#define FF(i,a) for( int i = 0 ; i < (a) ; i ++) +#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --) +#define S64(a) scanf(in64,&a) +#define SS(a) scanf("%d",&a) +#define LL(a) ((a)<<1) +#define RR(a) (((a)<<1)+1) +#define pb push_back +#define pf push_front +#define X first +#define Y second +#define CL(Q) while(!Q.empty())Q.pop() +#define MM(name,what) memset(name,what,sizeof(name)) +#define MC(a,b) memcpy(a,b,sizeof(b)) +#define MAX(a,b) ((a)>(b)?(a):(b)) +#define MIN(a,b) ((a)<(b)?(a):(b)) +#define read freopen("out.txt","r",stdin) +#define write freopen("out2.txt","w",stdout) +const int inf = 0x3f3f3f3f; +const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL; +const double oo = 10e9; +const double eps = 10e-9; +const double pi = acos(-1.0); +const int maxn = 1 << 20; +const i64 mod = 4294967296; +struct zz{ + string s; + i64 a; +}zx; +int n; +int c[44][32]; +string s[44]; +i64 a[44]; +i64 dp[maxn]; +i64 dpx[maxn]; +int cas[44]; +int ret[22]; +vectorv; +int ns; +int size; +i64 start(){ + for (int i = 0; i < (1 << ns); i++){ + dp[i] = -1; + } + dp[0] = 0; + size = v.size(); + for (int step = 0; step < 32; step++){ + for (int state = 0; state < (1 << ns); state++){ + dpx[state] = -1; + } + for (int state = 0; state < (1 << ns); state++) if(dp[state] != -1){ + i64 tos = 0; + i64 value = 0; + for (int i = 0; i < size; i++){ + if (v[i].s == "+="){ + if (state & (1 << cas[i])){ + if (c[i][step] == 4){ + tos |= 1 << cas[i]; + } + else if( c[i][step] == 2){ + if (value == 1){ + tos |= 1 << cas[i]; + value = 0; + } + else{ + value = 1; + } + } + } + else{ + if (c[i][step] == 4){ + if (value == 1){ + tos |= 1 << cas[i]; + value = 0; + } + else { + value = 1; + } + } + } + } + else{ + if (c[i][step] == 0){ + value = 0; + } + else if (c[i][step] == 1){ + value = 1; + } + else if (c[i][step] == 3){ + value = 1 - value; + } + } + } + i64 temp = value << step; + temp += dp[state]; + if (temp > dpx[tos]){ + dpx[tos] = temp; + } + tos = 0; + value = 1; + for (int i = 0; i < size; i++){ + if (v[i].s == "+="){ + if (state & (1 << cas[i])){ + if (c[i][step] == 4){ + tos |= 1 << cas[i]; + } + else if (c[i][step] == 2){ + if (value == 1){ + tos |= 1 << cas[i]; + value = 0; + } + else{ + value = 1; + } + } + } + else{ + if (c[i][step] == 4){ + if (value == 1){ + tos |= 1 << cas[i]; + value = 0; + } + else { + value = 1; + } + } + } + } + else{ + if (c[i][step] == 0){ + value = 0; + } + else if (c[i][step] == 1){ + value = 1; + } + else if (c[i][step] == 3){ + value = 1 - value; + } + } + } + temp = value << step; + temp += dp[state]; + if (temp > dpx[tos]){ + dpx[tos] = temp; + } + } + for (int state = 0; state < (1 << ns); state++){ + dp[state] = dpx[state]; + } + } + i64 ans = -1; + for (int i = 0; i < (1 << ns); i++){ + ans = max(ans, dp[i]); + } + return ans; +} +i64 toint(string temp){ + i64 re = 0; + for (int i = 0; i < temp.size(); i++){ + if (temp[i] <= '9' && temp[i] >= '0'){ + re *= (1 << 4); + re += temp[i] - '0'; + } + else if (temp[i] >= 'a' && temp[i] <= 'f'){ + re *= (1 << 4); + re += temp[i] - 'a' + 10; + } + } + return re; +} +int main(){ + int T; + cin >> T; + while (T--){ + cin >> n; + string ts; + for (int i = 1; i <= n; i++){ + cin >> s[i] >> ts; + a[i] = toint(ts); + if (s[i] == "-="){ + s[i] = "+="; + a[i] = -a[i]; + a[i] = (a[i] + mod) % mod; + } + } + v.clear(); + int temp; + for (int i = 1; i <= n; i++){ + zx.s = s[i]; + zx.a = a[i]; + if (zx.s == "+="){ + temp = i + 1; + while (true){ + if (temp<=n && s[temp] == "+="){ + zx.a += a[temp]; + zx.a %= mod; + temp++; + } + else{ + i = temp - 1; + break; + } + } + v.push_back(zx); + } + else { + v.push_back(zx); + } + } + ns = 0; + for (int x = 0; x