KiritoTRw
GitHub
parent
6d0ead9b6a
commit
b39288d6ef
|
|
@ -0,0 +1,61 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN= 100002;
|
||||
int a[MAXN], m, n, b1, b2, len[MAXN], ch[MAXN];
|
||||
long long ans;
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
while(scanf("%d%d%d", &n, &b1, &b2) != -1)
|
||||
{
|
||||
for(i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d", &a[i]);
|
||||
}
|
||||
ans = 0;
|
||||
len[1] = 1;
|
||||
for(i = 2; i <= n; i++)
|
||||
{
|
||||
ch[i] = a[i] - a[i-1];
|
||||
if(i == 2)
|
||||
{
|
||||
if(a[2]-a[1] == b1 || a[2] - a[1] == b2)
|
||||
len[i] = 2;
|
||||
else len[i] = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(ch[i] == ch[i-1])
|
||||
{
|
||||
if(ch[i] == b1 || ch[i] == b2)
|
||||
len[i] = len[i-1] + 1;
|
||||
else
|
||||
len[i] = 1;
|
||||
}
|
||||
else if(ch[i] == b2 && ch[i-1] == b1)
|
||||
{
|
||||
len[i] = len[i-1] + 1;
|
||||
}
|
||||
else if(ch[i] == b1 || ch[i] == b2)
|
||||
{
|
||||
len[i] = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
len[i] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i = 1; i<= n; i++)
|
||||
{
|
||||
ans += len[i];
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<cmath>
|
||||
#include<string.h>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<math.h>
|
||||
#define ll long long
|
||||
#define pi acos(-1)
|
||||
#define PLL pair<ll,ll>
|
||||
#define PLLL pair<PLL,ll>
|
||||
#define MP make_pair
|
||||
using namespace std;
|
||||
const ll mod = 1e9+7;
|
||||
const ll maxn= 1000+10;
|
||||
ll m,a[maxn],b[maxn],c[maxn],d[maxn],l[maxn],ans[maxn],s[maxn],cc[maxn],dd[maxn];
|
||||
map<PLLL,ll> ma;
|
||||
ll calc(ll p,ll x,ll y){
|
||||
if(p==0) return 0;
|
||||
PLLL r=MP(MP(p,x),y);
|
||||
if(ma.find(r)!=ma.end()) return ma[r];
|
||||
if(x<s[a[p]]&&y<s[a[p]]) return ma[r]=(calc(a[p],x,y)%mod);
|
||||
else if(x<s[a[p]]&&y>=s[a[p]]) return ma[r]=(calc(a[p],x,c[p])+calc(b[p],y-s[a[p]],d[p])+l[p])%mod;
|
||||
else if(x>=s[a[p]]&&y<s[a[p]]) return ma[r]=(calc(a[p],y,c[p])+calc(b[p],x-s[a[p]],d[p])+l[p])%mod;
|
||||
else return ma[r]=(calc(b[p],x-s[a[p]],y-s[a[p]])%mod);
|
||||
}
|
||||
ll solve(ll p,ll id){
|
||||
if(p==0) return 0;
|
||||
if(id<s[a[p]])
|
||||
return ((calc(a[p],id,c[p])+l[p])%mod*(s[b[p]]%mod)%mod+(dd[p]+solve(a[p],id))%mod)%mod;
|
||||
else{
|
||||
id=(id-s[a[p]]);
|
||||
return ((calc(b[p],id,d[p])+l[p])%mod*(s[a[p]]%mod)%mod+(cc[p]+solve(b[p],id))%mod)%mod;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%lld",&m)!=EOF){
|
||||
s[0]=1; a[0]=b[0]=c[0]=d[0]=cc[0]=dd[0]=l[0]=0; ma.clear();
|
||||
for(ll i=1;i<=m;i++) s[i]=ans[i]=0;
|
||||
for(ll i=1;i<=m;i++){
|
||||
scanf("%lld%lld%lld%lld%lld",&a[i],&b[i],&c[i],&d[i],&l[i]); s[i]=s[a[i]]+s[b[i]];
|
||||
cc[i]=solve(a[i],c[i])%mod,dd[i]=solve(b[i],d[i])%mod;
|
||||
ans[i]=((cc[i]*(s[b[i]]%mod)%mod)+(dd[i]*(s[a[i]]%mod)%mod)+l[i]%mod*(s[a[i]]%mod)%mod*(s[b[i]]%mod)%mod+(ans[a[i]]+ans[b[i]])%mod)%mod;
|
||||
printf("%lld\n",ans[i]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<cstdio>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<functional>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL base = 1e9 + 7;
|
||||
const int maxn = 105;
|
||||
LL T, n, m, a[maxn][maxn], sum, x, y;
|
||||
inline void read(int &x)
|
||||
{
|
||||
char ch;
|
||||
while ((ch = getchar())<'0' || ch>'9');
|
||||
x = ch - '0';
|
||||
while ((ch = getchar()) >= '0' && ch <= '9') x = x * 10 + ch - '0';
|
||||
}
|
||||
void get()
|
||||
{
|
||||
x = 1; y = 2;
|
||||
for (int i = 1; i <= n;i++)
|
||||
for (int j = 1; j <= m; j++)
|
||||
if (((i + j) & 1) && a[x][y] > a[i][j]) x = i, y = j;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%lld%lld", &n, &m) !=EOF)
|
||||
{
|
||||
sum = 0;
|
||||
for (int i = 1; i <= n;i++)
|
||||
for (int j = 1; j <= m; j++)
|
||||
{
|
||||
scanf("%lld", &a[i][j]);
|
||||
sum += a[i][j];
|
||||
}
|
||||
if (n & 1 || m & 1)
|
||||
{
|
||||
printf("%lld\n", sum);
|
||||
if (n & 1)
|
||||
{
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
for (int j = 1; j < m; j++)
|
||||
if (i & 1) printf("R"); else printf("L");
|
||||
if (i < n) printf("D"); else printf("\n");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = 1; i <= m; i++)
|
||||
{
|
||||
for (int j = 1; j < n; j++)
|
||||
if (i & 1) printf("D"); else printf("U");
|
||||
if (i < m) printf("R"); else printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
get();
|
||||
printf("%lld\n", sum - a[x][y]);
|
||||
for (int i = 1; i <= n; i += 2)
|
||||
{
|
||||
if (x == i || x == i + 1)
|
||||
{
|
||||
for (int j = 1; j < y; j++)
|
||||
{
|
||||
if (j & 1) printf("D"); else printf("U");
|
||||
printf("R");
|
||||
}
|
||||
if (y < m) printf("R");
|
||||
for (int j = y + 1; j <= m; j++)
|
||||
{
|
||||
if (j & 1) printf("U"); else printf("D");
|
||||
if (j < m) printf("R");
|
||||
}
|
||||
if (i < n - 1) printf("D");
|
||||
}
|
||||
else if (i < x)
|
||||
{
|
||||
for (int j = 1; j < m; j++) printf("R");
|
||||
printf("D");
|
||||
for (int j = 1; j < m; j++) printf("L");
|
||||
printf("D");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int j = 1; j < m; j++) printf("L");
|
||||
printf("D");
|
||||
for (int j = 1; j < m; j++) printf("R");
|
||||
if (i < n - 1) printf("D");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,182 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#define maxn 200007
|
||||
#define inf 1000000000
|
||||
#define ll long long
|
||||
ll mod = 1000000007;
|
||||
struct Node{
|
||||
Node *fa,*ch[2];
|
||||
bool rev,root;
|
||||
ll val,s1,s2,s3,s4;
|
||||
};
|
||||
Node pool[maxn];
|
||||
Node *nil,*tree[maxn];
|
||||
int cnt = 0;
|
||||
void init(){
|
||||
cnt = 1;
|
||||
nil = tree[0] = pool;
|
||||
nil->ch[0] = nil->ch[1] = nil;
|
||||
nil->s1 = nil->s2 = nil->val = nil->s3 = nil->s4 = 0;
|
||||
}
|
||||
Node *newnode(ll val,Node *f){
|
||||
pool[cnt].fa = f;
|
||||
pool[cnt].ch[0]=pool[cnt].ch[1]=nil;
|
||||
pool[cnt].rev = false;
|
||||
pool[cnt].root = true;
|
||||
pool[cnt].val = val;
|
||||
pool[cnt].s1 = 0;
|
||||
pool[cnt].s2 = 0;
|
||||
pool[cnt].s3 = 0;
|
||||
pool[cnt].s4 = 0;
|
||||
return &pool[cnt++];
|
||||
}
|
||||
void update_rev(Node *x){
|
||||
if(x == nil) return ;
|
||||
x->rev = !x->rev;
|
||||
swap(x->ch[0],x->ch[1]);
|
||||
}
|
||||
void update(Node *x){
|
||||
if(x == nil) return ;
|
||||
x->s2 = x->s1 + x->val;
|
||||
x->s4 = x->s3;
|
||||
if(x->ch[0] != nil){
|
||||
x->s2 += x->ch[0]->s2;
|
||||
if(x->s2 >= mod)
|
||||
x->s2 -= mod;
|
||||
x->s4 += x->ch[0]->s4;
|
||||
x->s4 %= mod;
|
||||
}
|
||||
if(x->ch[1] != nil){
|
||||
x->s2 += x->ch[1]->s2;
|
||||
if(x->s2 >= mod)
|
||||
x->s2 -= mod;
|
||||
x->s4 += x->ch[1]->s4;
|
||||
x->s4 %= mod;
|
||||
}
|
||||
}
|
||||
void pushdown(Node *x){
|
||||
if(x->rev != false){
|
||||
update_rev(x->ch[0]);
|
||||
update_rev(x->ch[1]);
|
||||
x->rev = false;
|
||||
}
|
||||
}
|
||||
void push(Node *x){
|
||||
if(!x->root) push(x->fa);
|
||||
pushdown(x);
|
||||
}
|
||||
void rotate(Node *x){
|
||||
Node *f = x->fa, *ff = f->fa;
|
||||
int t = (f->ch[1] == x);
|
||||
if(f->root)
|
||||
x->root = true, f->root = false;
|
||||
else ff->ch[ff->ch[1] == f] = x;
|
||||
x->fa = ff;
|
||||
f->ch[t] = x->ch[t^1];
|
||||
x->ch[t^1]->fa = f;
|
||||
x->ch[t^1] = f;
|
||||
f->fa = x;
|
||||
update(f);
|
||||
}
|
||||
void splay(Node *x){
|
||||
push(x);
|
||||
Node *f, *ff;
|
||||
while(!x->root){
|
||||
f = x->fa,ff = f->fa;
|
||||
if(!f->root)
|
||||
if((ff->ch[1]==f)&&(f->ch[1] == x)) rotate(f);
|
||||
else rotate(x);
|
||||
rotate(x);
|
||||
}
|
||||
update(x);
|
||||
}
|
||||
Node *access(Node *x){
|
||||
Node *y = nil,*z;
|
||||
while(x != nil){
|
||||
splay(x);
|
||||
z = x->ch[1];
|
||||
x->ch[1]->root = true;
|
||||
(x->ch[1] = y)->root = false;
|
||||
update(z);
|
||||
x->s1 += z->s2;
|
||||
x->s3 += (z->s2*z->s2);
|
||||
x->s1 %= mod;
|
||||
x->s3 %= mod;
|
||||
x->s1 -= y->s2;
|
||||
x->s3 -= y->s2*y->s2;
|
||||
x->s1 %= mod;
|
||||
x->s3 %= mod;
|
||||
update(x);
|
||||
y = x;
|
||||
x = x->fa;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
void be_root(Node *x){
|
||||
access(x);
|
||||
splay(x);
|
||||
update_rev(x);
|
||||
}
|
||||
int value[maxn];
|
||||
vector<int> head[maxn];
|
||||
void dfs(int u,int f){
|
||||
tree[u]->fa = tree[f];
|
||||
for(int i = 0;i < head[u].size() ;i++){
|
||||
int v = head[u][i];
|
||||
if(v == f) continue;
|
||||
dfs(v,u);
|
||||
tree[u]->s1 += tree[v]->s2;
|
||||
tree[u]->s1 %= mod;
|
||||
tree[u]->s3 += tree[v]->s2*tree[v]->s2;
|
||||
tree[u]->s3 %= mod;
|
||||
}
|
||||
update(tree[u]);
|
||||
}
|
||||
int main(){
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)!=EOF){
|
||||
for(int i = 1;i <= n; i++)
|
||||
scanf("%d",&value[i]);
|
||||
for(int i = 0;i <= n; i++)
|
||||
head[i].clear();
|
||||
int u,v;
|
||||
for(int i = 1;i < n; i++){
|
||||
scanf("%d%d",&v,&u);
|
||||
head[v].push_back(u);
|
||||
head[u].push_back(v);
|
||||
}
|
||||
init();
|
||||
for(int i=1;i <= n;i++)
|
||||
tree[i] = newnode(value[i],nil);
|
||||
dfs(1,0);
|
||||
ll total = 0;
|
||||
for(int i = 1;i <= n; i++)
|
||||
total += value[i];
|
||||
total %= mod;
|
||||
int t;
|
||||
for(int i = 0;i < m; i++){
|
||||
scanf("%d%d%d",&t,&u,&v);
|
||||
if(t == 1){
|
||||
be_root(tree[u]);
|
||||
access(tree[u]);
|
||||
total = total + v - tree[u]->val;
|
||||
total %= mod;
|
||||
tree[u]->val = v;
|
||||
update(tree[u]);
|
||||
}
|
||||
else {
|
||||
be_root(tree[u]);
|
||||
access(tree[v]);
|
||||
splay(tree[v]);
|
||||
ll ans = total*total%mod-tree[v]->s4;
|
||||
ans = (ans%mod+mod)%mod;
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,457 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <unordered_map>
|
||||
#include <queue>
|
||||
#include <sstream>
|
||||
using namespace std;
|
||||
const int MAXN = 1005;
|
||||
struct A{
|
||||
int H, D;
|
||||
bool operator<(const A rhs)const{
|
||||
if(H != rhs.H)
|
||||
return H > rhs.H;
|
||||
else
|
||||
return D < rhs.D;
|
||||
}
|
||||
}arr[MAXN];
|
||||
int N;
|
||||
int dval[MAXN], dvn;
|
||||
#define MAXP 2010
|
||||
#define MAXQ 1000005
|
||||
#define MAXI 0x7fffffff
|
||||
#define MAXC 0x0fffffff
|
||||
#define BIGM MAXC
|
||||
struct EDGE{
|
||||
int st, ed;
|
||||
int flow;
|
||||
int low;
|
||||
int upf;
|
||||
int cost;
|
||||
int hnext;
|
||||
int tnext;
|
||||
int hprev;
|
||||
int tprev;
|
||||
char set;
|
||||
}edge[MAXQ+MAXP];
|
||||
int ecnt;
|
||||
int ecnt2;
|
||||
int sece;
|
||||
bool search_method;
|
||||
struct NODE{
|
||||
int head;
|
||||
int tail;
|
||||
int d;
|
||||
int pi;
|
||||
int pred;
|
||||
int depth;
|
||||
}node[MAXP];
|
||||
int ncnt;
|
||||
struct LOOP{
|
||||
int e;
|
||||
int prev;
|
||||
int next;
|
||||
}loop[MAXP+3];
|
||||
int lcnt;
|
||||
int addedge(int a, int b, int low, int upf, int cost, int &cnt)
|
||||
{
|
||||
edge[cnt].st = a;
|
||||
edge[cnt].ed = b;
|
||||
edge[cnt].low = low;
|
||||
edge[cnt].upf = upf;
|
||||
edge[cnt].cost = cost;
|
||||
edge[cnt].hnext = -1;
|
||||
edge[cnt].tnext = -1;
|
||||
edge[cnt].hprev = -1;
|
||||
edge[cnt].tprev = -1;
|
||||
cnt++;
|
||||
return (cnt - 1);
|
||||
}
|
||||
void insert_tree(int j)
|
||||
{
|
||||
int a, b;
|
||||
a = edge[j].st;
|
||||
b = edge[j].ed;
|
||||
edge[j].hprev = -1;
|
||||
edge[j].hnext = node[a].head;
|
||||
if(node[a].head >= 0)
|
||||
edge[node[a].head].hprev = j;
|
||||
node[a].head = j;
|
||||
edge[j].tprev = -1;
|
||||
edge[j].tnext = node[b].tail;
|
||||
if(node[b].tail >= 0)
|
||||
edge[node[b].tail].tprev = j;
|
||||
node[b].tail = j;
|
||||
}
|
||||
void delete_tree(int j)
|
||||
{
|
||||
int a, b;
|
||||
a = edge[j].st;
|
||||
b = edge[j].ed;
|
||||
if(edge[j].hprev >= 0)
|
||||
{
|
||||
edge[edge[j].hprev].hnext = edge[j].hnext;
|
||||
}else{
|
||||
node[a].head = edge[j].hnext;
|
||||
}
|
||||
if(edge[j].hnext >= 0)
|
||||
{
|
||||
edge[edge[j].hnext].hprev = edge[j].hprev;
|
||||
}
|
||||
edge[j].hprev = -1;
|
||||
edge[j].hnext = -1;
|
||||
if(edge[j].tprev >= 0)
|
||||
{
|
||||
edge[edge[j].tprev].tnext = edge[j].tnext;
|
||||
}else{
|
||||
node[b].tail = edge[j].tnext;
|
||||
}
|
||||
if(edge[j].tnext >= 0)
|
||||
{
|
||||
edge[edge[j].tnext].tprev = edge[j].tprev;
|
||||
}
|
||||
edge[j].tprev = -1;
|
||||
edge[j].tnext = -1;
|
||||
}
|
||||
void M_init()
|
||||
{
|
||||
int i, j;
|
||||
node[0].d = 0;
|
||||
node[0].head = -1;
|
||||
node[0].tail = -1;
|
||||
for(i=0;i<ecnt;i++)
|
||||
{
|
||||
edge[i].flow = edge[i].low;
|
||||
edge[i].set = 'L';
|
||||
node[edge[i].st].d -= edge[i].low;
|
||||
node[edge[i].ed].d += edge[i].low;
|
||||
}
|
||||
ecnt2 = ecnt;
|
||||
for(i=1;i<=ncnt;i++)
|
||||
{
|
||||
if(node[i].d > 0)
|
||||
{
|
||||
j = addedge(i, 0, 0, MAXC, BIGM, ecnt2);
|
||||
edge[j].flow = node[i].d;
|
||||
}else{
|
||||
j = addedge(0, i, 0, MAXC, BIGM, ecnt2);
|
||||
edge[j].flow = -node[i].d;
|
||||
}
|
||||
edge[j].set = 'T';
|
||||
insert_tree(j);
|
||||
}
|
||||
}
|
||||
void calc_pi(int root, int val, int dep, int pred)
|
||||
{
|
||||
int j;
|
||||
node[root].pi = val;
|
||||
node[root].depth = dep;
|
||||
node[root].pred = pred;
|
||||
for(j=node[root].head;j!=-1;j=edge[j].hnext)
|
||||
{
|
||||
if(j != pred)
|
||||
{
|
||||
calc_pi(edge[j].ed, val - edge[j].cost, dep + 1, j);
|
||||
}
|
||||
}
|
||||
for(j=node[root].tail;j!=-1;j=edge[j].tnext)
|
||||
{
|
||||
if(j != pred)
|
||||
{
|
||||
calc_pi(edge[j].st, val + edge[j].cost, dep + 1, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
int calc_dual1()
|
||||
{
|
||||
int i, ret = -1, dual0 = -1, dual;
|
||||
for(i=0;i<ecnt2;i++)
|
||||
{
|
||||
dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
|
||||
if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
|
||||
{
|
||||
dual = labs(dual);
|
||||
if(dual > dual0)
|
||||
{
|
||||
ret = i;
|
||||
dual0 = dual;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int calc_dual2()
|
||||
{
|
||||
int i, dual;
|
||||
for(i=sece;i<ecnt2;i++)
|
||||
{
|
||||
dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
|
||||
if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
|
||||
{
|
||||
sece = i + 1;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
for(i=0;i<sece;i++)
|
||||
{
|
||||
dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
|
||||
if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
|
||||
{
|
||||
sece = i + 1;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
bool augment(int rda)
|
||||
{
|
||||
int p, q;
|
||||
int pl, ql, pp, qp, maxflow;
|
||||
bool flagp, flagq, flag, ret;
|
||||
lcnt = 0;
|
||||
if(edge[rda].set == 'L')
|
||||
{
|
||||
p = edge[rda].st;
|
||||
q = edge[rda].ed;
|
||||
}else{
|
||||
q = edge[rda].st;
|
||||
p = edge[rda].ed;
|
||||
}
|
||||
loop[lcnt].e = rda;
|
||||
loop[lcnt].prev = 1;
|
||||
loop[lcnt].next = 2;
|
||||
pl = 1;
|
||||
ql = 2;
|
||||
loop[pl].e = -1;
|
||||
loop[pl].next = 0;
|
||||
loop[pl].prev = -1;
|
||||
loop[ql].e = -1;
|
||||
loop[ql].next = -1;
|
||||
loop[ql].prev = 0;
|
||||
lcnt = 3;
|
||||
maxflow = edge[rda].upf - edge[rda].low;
|
||||
while(p != q)
|
||||
{
|
||||
if(node[p].depth > node[q].depth)
|
||||
{
|
||||
flagp = true;
|
||||
flagq = false;
|
||||
}else if(node[p].depth < node[q].depth)
|
||||
{
|
||||
flagp = false;
|
||||
flagq = true;
|
||||
}else{
|
||||
flagp = true;
|
||||
flagq = true;
|
||||
}
|
||||
if(flagp)
|
||||
{
|
||||
pp = node[p].pred;
|
||||
if(edge[pp].ed == p)
|
||||
{
|
||||
maxflow = min(maxflow, edge[pp].upf - edge[pp].flow);
|
||||
p = edge[pp].st;
|
||||
}else{
|
||||
maxflow = min(maxflow, edge[pp].flow - edge[pp].low);
|
||||
p = edge[pp].ed;
|
||||
}
|
||||
loop[pl].e = pp;
|
||||
loop[pl].prev = lcnt;
|
||||
loop[lcnt].e = -1;
|
||||
loop[lcnt].next = pl;
|
||||
loop[lcnt].prev = -1;
|
||||
pl = lcnt;
|
||||
lcnt++;
|
||||
}
|
||||
if(flagq)
|
||||
{
|
||||
qp = node[q].pred;
|
||||
if(edge[qp].st == q)
|
||||
{
|
||||
maxflow = min(maxflow, edge[qp].upf - edge[qp].flow);
|
||||
q = edge[qp].ed;
|
||||
}else{
|
||||
maxflow = min(maxflow, edge[qp].flow - edge[qp].low);
|
||||
q = edge[qp].st;
|
||||
}
|
||||
loop[ql].e = qp;
|
||||
loop[ql].next = lcnt;
|
||||
loop[lcnt].e = -1;
|
||||
loop[lcnt].next = -1;
|
||||
loop[lcnt].prev = ql;
|
||||
ql = lcnt;
|
||||
lcnt++;
|
||||
}
|
||||
}
|
||||
flag = false;
|
||||
while(loop[pl].next >= 0)
|
||||
{
|
||||
pl = loop[pl].next;
|
||||
ql = loop[pl].e;
|
||||
if(ql == -1)
|
||||
break;
|
||||
if(ql == rda)
|
||||
{
|
||||
ret = (flag == (edge[rda].set == 'L'));
|
||||
}
|
||||
if(edge[ql].st == p)
|
||||
{
|
||||
edge[ql].flow += maxflow;
|
||||
if(!flag && (edge[ql].flow == edge[ql].upf))
|
||||
{
|
||||
edge[ql].set = 'U';
|
||||
flag = true;
|
||||
delete_tree(ql);
|
||||
}else{
|
||||
edge[ql].set = 'T';
|
||||
}
|
||||
p = edge[ql].ed;
|
||||
}else{
|
||||
edge[ql].flow -= maxflow;
|
||||
if(!flag && (edge[ql].flow == edge[ql].low))
|
||||
{
|
||||
edge[ql].set = 'L';
|
||||
flag = true;
|
||||
delete_tree(ql);
|
||||
}else{
|
||||
edge[ql].set = 'T';
|
||||
}
|
||||
p = edge[ql].st;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool NSMCalc(int &cost)
|
||||
{
|
||||
int rda, i;
|
||||
M_init();
|
||||
calc_pi(0, 0, 0, -1);
|
||||
rda = (search_ ? calc_dual1() : calc_dual2());
|
||||
while(rda >= 0)
|
||||
{
|
||||
int j;
|
||||
insert_tree(rda);
|
||||
if(augment(rda))
|
||||
{
|
||||
i = edge[rda].st;
|
||||
j = edge[rda].ed;
|
||||
calc_pi(i, node[j].pi + edge[rda].cost, node[j].depth + 1, rda);
|
||||
}else{
|
||||
i = edge[rda].ed;
|
||||
j = edge[rda].st;
|
||||
calc_pi(i, node[j].pi - edge[rda].cost, node[j].depth + 1, rda);
|
||||
}
|
||||
rda = (search_ ? calc_dual1() : calc_dual2());
|
||||
}
|
||||
for(i=ecnt;i<ecnt2;i++)
|
||||
{
|
||||
if(edge[i].flow > 0)
|
||||
return false;
|
||||
}
|
||||
cost = 0;
|
||||
for(i=0;i<ecnt;i++)
|
||||
{
|
||||
cost += edge[i].flow * edge[i].cost;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void init_graph(int pointnum, bool method)
|
||||
{
|
||||
int i;
|
||||
ncnt = pointnum;
|
||||
ecnt = 0;
|
||||
sece = 0;
|
||||
for(i=0;i<=ncnt;i++)
|
||||
{
|
||||
node[i].d = 0;
|
||||
node[i].head = -1;
|
||||
node[i].tail = -1;
|
||||
node[i].pred = -1;
|
||||
node[i].pi = 0;
|
||||
node[i].depth = 0;
|
||||
}
|
||||
search_method = method;
|
||||
}
|
||||
inline char getc(){
|
||||
static const int BUFLEN = 1 << 15;
|
||||
static char B[BUFLEN], *S = B, *T = B;
|
||||
if(S == T){
|
||||
S = B;
|
||||
T = S + fread(B, 1, BUFLEN, stdin);
|
||||
}
|
||||
return (S == T) ? 0 : *(S ++);
|
||||
}
|
||||
int ReadInt(){
|
||||
char ch;
|
||||
do ch = getc(); while(!isdigit(ch));
|
||||
int aa = ch - '0';
|
||||
for(ch = getc(); isdigit(ch); ch = getc())
|
||||
aa = aa * 10 + ch - '0';
|
||||
return aa;
|
||||
}
|
||||
int calc(){
|
||||
int i, j;
|
||||
int ret, mxv;
|
||||
init_graph(N * 2 + 3, false);
|
||||
addedge(0, 1, 0, 2, 0, ecnt);
|
||||
for(i = 1; i <= N; i ++){
|
||||
addedge(1, i + 1, 0, 1, 0, ecnt);
|
||||
addedge(i + N + 1, N * 2 + 2, 0, 1, 0, ecnt);
|
||||
addedge(i + 1, i + N + 1, 0, 1, -1, ecnt);
|
||||
}
|
||||
for(i = 1; i <= N; i ++){
|
||||
mxv = 0x3fffffff;
|
||||
for(j = i + 1; j <= N; j ++){
|
||||
if(arr[j].D < arr[i].D || arr[j].D >= mxv)
|
||||
continue;
|
||||
addedge(i + N + 1, j + 1, 0, 1, 0, ecnt);
|
||||
addedge(i + 1, j + 1, 0, 1, 0, ecnt);
|
||||
mxv = arr[j].D;
|
||||
}
|
||||
}
|
||||
node[0].d = 2;
|
||||
node[N * 2 + 2].d = -2;
|
||||
NSMCalc(ret);
|
||||
return - ret;
|
||||
}
|
||||
bool deal1(){
|
||||
int i;
|
||||
for(i = 1; i <= N; i ++){
|
||||
if(arr[i + 1].D < arr[i].D)
|
||||
return false;
|
||||
}
|
||||
printf("%d\n", N);
|
||||
return true;
|
||||
}
|
||||
void domain(){
|
||||
int i, ans = 0;
|
||||
N = ReadInt();
|
||||
for(i = 1; i <= N; i ++){
|
||||
arr[i].H = ReadInt();
|
||||
arr[i].D = ReadInt();
|
||||
}
|
||||
sort(arr + 1, arr + N + 1);
|
||||
dvn = 0;
|
||||
for(i = 1; i <= N; i ++){
|
||||
dval[dvn ++] = arr[i].D;
|
||||
}
|
||||
sort(dval, dval + dvn);
|
||||
dvn = unique(dval, dval + dvn) - dval;
|
||||
for(i = 1; i <= N; i ++){
|
||||
arr[i].D = lower_bound(dval, dval + dvn, arr[i].D) - dval + 1;
|
||||
}
|
||||
ans = calc();
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
int main(){
|
||||
int T = ReadInt();
|
||||
while(T --){
|
||||
domain();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
#define prt(k) cerr<<#k" = "<<k<<endl
|
||||
typedef long long ll;
|
||||
const int inf = 0x3f3f3f3f;
|
||||
const ll mod = 1e9 + 7;
|
||||
const int N = 1000100;
|
||||
ll p[N];
|
||||
ll a[N];
|
||||
bool ok(ll n)
|
||||
{
|
||||
int t = p[n];
|
||||
while (n % t==0 && n > 1) n /= t;
|
||||
return n==1;
|
||||
}
|
||||
ll pmod(ll a, ll n)
|
||||
{
|
||||
ll ret = 1;
|
||||
for (; n; n>>=1, a=a*a%mod) if (n & 1)
|
||||
ret = ret * a % mod;
|
||||
return ret;
|
||||
}
|
||||
ll inv(ll a)
|
||||
{
|
||||
return pmod(a, mod - 2);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for (int i=1;i<N;i++) p[i]=i;
|
||||
for (int i=2;i<N;i++) if (p[i]==i) {
|
||||
for (int j=i+i;j<N;j+=i) p[j] = i;
|
||||
}
|
||||
a[0] = 1;
|
||||
for (int i=1;i<N;i++) {
|
||||
if (ok(i))
|
||||
a[i] = a[i-1] * p[i] % mod;
|
||||
else
|
||||
a[i] = a[i-1];
|
||||
}
|
||||
int n; int re; cin>>re;
|
||||
while (re--) {
|
||||
scanf("%d", &n);
|
||||
n++;
|
||||
ll ans = a[n] * inv(n) % mod;
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 100005;
|
||||
struct NODE;
|
||||
struct EDGE{
|
||||
NODE *a, *b;
|
||||
EDGE *next;
|
||||
int u;
|
||||
bool bridge;
|
||||
}edge[MAXN << 1];
|
||||
struct NODE{
|
||||
EDGE *head;
|
||||
NODE *par;
|
||||
int DFN, low;
|
||||
int mv;
|
||||
}node[MAXN];
|
||||
int ecnt, dep, n, m;
|
||||
void Tarjan(NODE *x){
|
||||
x->DFN = x->low = ++ dep;
|
||||
for(EDGE *j = x->head; j; j = j->next){
|
||||
NODE *p = j->b;
|
||||
if(p == x->par)
|
||||
continue;
|
||||
if(!p->DFN){
|
||||
p->par = x;
|
||||
Tarjan(p);
|
||||
}
|
||||
j->bridge = p->low > x->DFN;
|
||||
x->low = min(x->low, p->low);
|
||||
x->mv = max(x->mv, p->mv);
|
||||
j->u = j->b->mv;
|
||||
}
|
||||
}
|
||||
void addedge(NODE *a, NODE *b, int& ecnt){
|
||||
EDGE *j = &edge[ecnt ++];
|
||||
j->a = a;
|
||||
j->b = b;
|
||||
j->next = a->head;
|
||||
a->head = j;
|
||||
j->bridge = false;
|
||||
}
|
||||
void domain(){
|
||||
int i, u, v;
|
||||
scanf("%d%d", &n, &m);
|
||||
ecnt = 0;
|
||||
for(i = 0; i <= n; i ++){
|
||||
node[i].mv = i;
|
||||
node[i].par = nullptr;
|
||||
node[i].DFN = 0;
|
||||
node[i].head = nullptr;
|
||||
}
|
||||
for(i = 0; i < m; i ++){
|
||||
scanf("%d%d", &u, &v);
|
||||
addedge(node + u, node + v, ecnt);
|
||||
addedge(node + v, node + u, ecnt);
|
||||
}
|
||||
dep = 0;
|
||||
Tarjan(node + n);
|
||||
for(i = 0; i < ecnt; ){
|
||||
u = 0;
|
||||
if(edge[i].bridge)
|
||||
u = edge[i].u;
|
||||
i ++;
|
||||
if(edge[i].bridge)
|
||||
u = edge[i].u;
|
||||
i ++;
|
||||
printf("%d %d\n", u, u > 0 ? u + 1 : 0);
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T --)
|
||||
domain();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 1005;
|
||||
int w[N], a[N], b[N];
|
||||
int dp[N][2005][2];
|
||||
int main(){
|
||||
int t; scanf("%d", &t);
|
||||
while (t--){
|
||||
int m, n; scanf("%d %d", &m, &n);
|
||||
for (int i = 1; i <= n; i++){
|
||||
scanf("%d %d %d", w + i, a + i, b + i);
|
||||
}
|
||||
memset(dp, 0, sizeof dp);
|
||||
for (int i = 1; i <= n; i++){
|
||||
for (int j = 0; j < w[i]; j++){
|
||||
dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
|
||||
dp[i][j][1] = 0;
|
||||
}
|
||||
for (int j = w[i]; j <= m; j++){
|
||||
dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
|
||||
dp[i][j][1] = max(dp[i][j - w[i]][0] + a[i] + b[i], dp[i][j - w[i]][1] + a[i]);
|
||||
}
|
||||
}
|
||||
int ans = max(dp[n][m][0], dp[n][m][1]);
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<ctime>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
const int base = 2015;
|
||||
const int maxn = 100005;
|
||||
int T, n, m, k, kk;
|
||||
struct Matrix
|
||||
{
|
||||
#define size 55
|
||||
int m[size][size];
|
||||
Matrix() { memset(m, 0, sizeof(m)); }
|
||||
void operator =(const Matrix&b) { memcpy(m, b.m, sizeof(m)); }
|
||||
Matrix operator *(const Matrix&b) {
|
||||
Matrix c;
|
||||
for (int i = 0; i < size; i++)
|
||||
for (int j = 0; j < size; j++)
|
||||
for (int k = 0; k < size; k++)
|
||||
c.m[i][k] = (c.m[i][k] + m[i][j] * b.m[j][k]) % base;
|
||||
return c;
|
||||
}
|
||||
Matrix get(int x)
|
||||
{
|
||||
Matrix a, b = *this;
|
||||
for (int f = 0; x; x >>= 1)
|
||||
{
|
||||
if (x & 1)
|
||||
if (f) a = a * b; else a = b, f = 1;
|
||||
b = b * b;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
};
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &T);
|
||||
while (T--)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
Matrix a, b;
|
||||
for (int i = 1; i <= n + 1; i++) a.m[i][n + 1] = 1;
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d", &k);
|
||||
for (int j = 1; j <= k; j++)
|
||||
{
|
||||
scanf("%d", &kk);
|
||||
a.m[i][kk] = 1;
|
||||
}
|
||||
}
|
||||
for (int i = 1; i <= n + 1; i++) b.m[1][i] = 1;
|
||||
a = a.get(m);
|
||||
b = b * a;
|
||||
if (m == 1) printf("%d\n", n + 1);
|
||||
else printf("%d\n", b.m[1][n + 1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,192 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cstdlib>
|
||||
#include <climits>
|
||||
#include <ctype.h>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-9;
|
||||
const double PI = acos(-1.00);
|
||||
const double e = exp(1.0);
|
||||
#define INF 0x3f3f3f3f
|
||||
#define N 600010
|
||||
#define M 100010
|
||||
struct treap
|
||||
{
|
||||
int key,wht,count,sz,ch[2];
|
||||
} tp[N*15];
|
||||
int tree[N<<1];
|
||||
int nodecount,root;
|
||||
int IDX(int l,int r)
|
||||
{
|
||||
return l+r | l!=r;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
tp[0].sz=0;
|
||||
tp[0].wht=-INF;
|
||||
nodecount=0;
|
||||
root=0;
|
||||
}
|
||||
void update(int x)
|
||||
{
|
||||
tp[x].sz=tp[tp[x].ch[0]].sz+tp[x].count+tp[tp[x].ch[1]].sz;
|
||||
}
|
||||
void rotate(int &x,int t)
|
||||
{
|
||||
int y=tp[x].ch[t];
|
||||
tp[x].ch[t]=tp[y].ch[!t];
|
||||
tp[y].ch[!t]=x;
|
||||
update(x);
|
||||
update(y);
|
||||
x=y;
|
||||
}
|
||||
void insert(int &x,int t)
|
||||
{
|
||||
if(! x)
|
||||
{
|
||||
x=++nodecount;
|
||||
tp[x].key=t;
|
||||
tp[x].wht=rand();
|
||||
tp[x].count=1;
|
||||
tp[x].ch[0]=tp[x].ch[1]=0;
|
||||
}
|
||||
else if(tp[x].key==t) tp[x].count++;
|
||||
else
|
||||
{
|
||||
int k=tp[x].key<t;
|
||||
insert(tp[x].ch[k],t);
|
||||
if(tp[x].wht<tp[tp[x].ch[k]].wht) rotate(x,k);
|
||||
}
|
||||
update(x);
|
||||
}
|
||||
void erase(int &x,int t)
|
||||
{
|
||||
if(tp[x].key==t)
|
||||
{
|
||||
if(tp[x].count==1)
|
||||
{
|
||||
if(! tp[x].ch[0] && ! tp[x].ch[1])
|
||||
{
|
||||
x=0;
|
||||
return;
|
||||
}
|
||||
rotate(x,tp[tp[x].ch[0]].wht<tp[tp[x].ch[1]].wht);
|
||||
erase(x,t);
|
||||
}
|
||||
else tp[x].count--;
|
||||
}
|
||||
else erase(tp[x].ch[tp[x].key<t],t);
|
||||
update(x);
|
||||
}
|
||||
int select(int x,int t)
|
||||
{
|
||||
if(! x) return 0;
|
||||
if(tp[x].key>t) return select(tp[x].ch[0],t);
|
||||
return tp[x].count+tp[tp[x].ch[0]].sz+select(tp[x].ch[1],t);
|
||||
}
|
||||
int a[N],b[N],ord[M][5],lb;
|
||||
int n,m,tt;
|
||||
int search(int x)
|
||||
{
|
||||
int l=1,r=b[0],mid;
|
||||
while (l<=r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(b[mid]==x) return mid;
|
||||
if(b[mid]<x) l=mid+1;
|
||||
else r=mid-1;
|
||||
}
|
||||
}
|
||||
void treeinsert(int l,int r,int i,int x)
|
||||
{
|
||||
insert(tree[IDX(l,r)],x);
|
||||
if(l==r) return;
|
||||
int m=(l+r)>>1;
|
||||
if(i<=m) treeinsert(l,m,i,x);
|
||||
else treeinsert(m+1,r,i,x);
|
||||
}
|
||||
void treedel(int l,int r,int i,int x)
|
||||
{
|
||||
erase(tree[IDX(l,r)],x);
|
||||
if(l==r) return;
|
||||
int m=(l+r)>>1;
|
||||
if(i<=m) treedel(l,m,i,x);
|
||||
else treedel(m+1,r,i,x);
|
||||
}
|
||||
int query(int l,int r,int x,int y,int k)
|
||||
{
|
||||
if(l==r) return l;
|
||||
int m=(l+r)>>1;
|
||||
int ans=select(tree[IDX(l,m)],y)-select(tree[IDX(l,m)],x);
|
||||
if(ans>=k) return query(l,m,x,y,k);
|
||||
return query(m+1,r,x,y,k-ans);
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
while (~scanf("%d",&n))
|
||||
{
|
||||
b[0]=1;
|
||||
lb=0;
|
||||
memset(tree,0,sizeof(tree));
|
||||
init();
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
b[++lb]=a[i];
|
||||
}
|
||||
scanf("%d",&m);
|
||||
for(int i=1; i<=m; i++)
|
||||
{
|
||||
int op;
|
||||
int x,y,c;
|
||||
scanf("%d",&op);
|
||||
if(op == 2)
|
||||
{
|
||||
scanf("%d %d %d",&x,&y,&c);
|
||||
ord[i][1]=1;
|
||||
ord[i][2]=x;
|
||||
ord[i][3]=y;
|
||||
ord[i][4]=c;
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d %d",&x,&y);
|
||||
ord[i][1]=2;
|
||||
ord[i][2]=x;
|
||||
ord[i][3]=y;
|
||||
b[++lb]=y;
|
||||
}
|
||||
}
|
||||
sort(b+1,b+1+lb);
|
||||
for(int i=1; i<=lb; i++)
|
||||
if(b[i]!=b[b[0]]) b[++b[0]]=b[i];
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
a[i]=search(a[i]);
|
||||
treeinsert(1,b[0],a[i],i);
|
||||
}
|
||||
for(int i=1; i<=m; i++)
|
||||
{
|
||||
if(ord[i][1]==1)
|
||||
printf("%d\n",b[query(1,b[0],ord[i][2]-1,ord[i][3],ord[i][4])]);
|
||||
else
|
||||
{
|
||||
treedel(1,b[0],a[ord[i][2]],ord[i][2]);
|
||||
a[ord[i][2]]=search(ord[i][3]);
|
||||
treeinsert(1,b[0],a[ord[i][2]],ord[i][2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int MAXN=20000 + 10;
|
||||
const int INF = numeric_limits<int>::max();
|
||||
const LL LL_INF= numeric_limits<LL>::max();
|
||||
int bit[MAXN][MAXN/32+100];
|
||||
struct Edge {
|
||||
int to,next;
|
||||
Edge(){}
|
||||
Edge(int _to,int _next):to(_to),next(_next){}
|
||||
}e[MAXN*10],e2[MAXN*10];
|
||||
int head[MAXN],tot,du[MAXN];
|
||||
int head2[MAXN],tot2;
|
||||
int n,m;
|
||||
void init(){
|
||||
for(int i=1;i<=n;i++)head2[i]=head[i]=-1,du[i]=0;
|
||||
tot2=0;
|
||||
tot=0;
|
||||
}
|
||||
void AddEdge(int u,int v){
|
||||
e[tot]=Edge(v,head[u]);
|
||||
head[u]=tot++;
|
||||
}
|
||||
void AddEdge1(int u,int v){
|
||||
e2[tot2]=Edge(v,head2[u]);
|
||||
head2[u]=tot2++;
|
||||
}
|
||||
int que[MAXN],front,rear;
|
||||
void _or(int posi,int posj){
|
||||
for(int i=0;i<=n/32;i++)bit[posi][i]|=bit[posj][i];
|
||||
}
|
||||
void top_bfs(){
|
||||
front=rear=0;
|
||||
memset(bit,0,sizeof(bit));
|
||||
for(int i=1;i<=n;i++){
|
||||
bit[i][i/32]=(1<<(i%32));
|
||||
if(du[i]==0){
|
||||
que[front++]=i;
|
||||
--du[i];
|
||||
}
|
||||
}
|
||||
while(front!=rear){
|
||||
int u=que[rear++];
|
||||
for(int i=head[u];~i;i=e[i].next){
|
||||
int v=e[i].to;
|
||||
AddEdge1(v,u);
|
||||
if(--du[v]==0)que[front++]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
template <class T>
|
||||
void Rd(T &tmp){
|
||||
char ch;
|
||||
while((ch=getchar())&&!isdigit(ch));
|
||||
tmp=0;
|
||||
do {
|
||||
tmp=(tmp<<3)+(tmp<<1)+(ch^48);
|
||||
}while((ch=getchar())&&isdigit(ch));
|
||||
return ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
Rd(T);
|
||||
while(T--){
|
||||
Rd(n),Rd(m);
|
||||
init();
|
||||
for(int i=0,x,y;i<m;i++){
|
||||
Rd(x),Rd(y);
|
||||
AddEdge(x,y);
|
||||
++du[y];
|
||||
}
|
||||
top_bfs();
|
||||
int ans=0;
|
||||
for(int i=0;i<front;i++){
|
||||
int u=que[i];
|
||||
for(int j=head2[u];~j;j=e2[j].next){
|
||||
int v=e2[j].to;
|
||||
if(bit[u][v/32]&(1<<(v%32)))++ans;
|
||||
_or(u,v);
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
const int maxn=100000+100;
|
||||
char s[maxn];
|
||||
char ts[maxn];
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%s%s",s,ts);
|
||||
int n1=strlen(s);
|
||||
int n2=strlen(ts);
|
||||
int cur=0;
|
||||
for(int i=0;i<n2;i++)
|
||||
{
|
||||
if(ts[i]==s[cur])
|
||||
cur++;
|
||||
if(cur==n1)
|
||||
break;
|
||||
}
|
||||
if(cur==n1)
|
||||
{
|
||||
int a1=1,a2=1;
|
||||
for(int j=1;j<n1;j++)
|
||||
{
|
||||
if(s[j]==s[0])
|
||||
a1++;
|
||||
else
|
||||
break;
|
||||
}
|
||||
for(int j=1;j<n2;j++)
|
||||
{
|
||||
if(ts[j]==ts[0])
|
||||
a2++;
|
||||
else
|
||||
break;
|
||||
}
|
||||
if(a2>a1||s[0]!=ts[0])
|
||||
printf("No\n");
|
||||
else
|
||||
printf("Yes\n");
|
||||
}
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
const int maxn = 1e6+10;
|
||||
typedef long long LL;
|
||||
int dp[maxn];
|
||||
int head[maxn],ip;
|
||||
LL cnt[maxn];
|
||||
int n;
|
||||
struct nod{
|
||||
int to,next,w;
|
||||
}edge[maxn];
|
||||
bool vis[maxn];
|
||||
void init(){
|
||||
ip=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(cnt,0,sizeof(cnt));
|
||||
memset(vis,0,sizeof(vis));
|
||||
}
|
||||
void add(int u,int v,int w){
|
||||
edge[ip].to=v;
|
||||
edge[ip].w=w;
|
||||
edge[ip].next=head[u];
|
||||
head[u]=ip++;
|
||||
}
|
||||
int mmax;
|
||||
void dfs(int u,int pre,int val){
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v= edge[i].to;
|
||||
if(v==pre) continue;
|
||||
if(edge[i].w^val>mmax)
|
||||
mmax = edge[i].w^val;
|
||||
cnt[edge[i].w^val]++;
|
||||
dfs(v,u,val^edge[i].w);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,m;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
init();
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n-1;i++){
|
||||
int u,v,w;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
add(u,v,w);
|
||||
add(v,u,w);
|
||||
}
|
||||
mmax = 0;
|
||||
dfs(1,1,0);
|
||||
scanf("%d",&m);
|
||||
cnt[0]++;
|
||||
for(int i=0;i<m;i++){
|
||||
int s;
|
||||
scanf("%d",&s);
|
||||
LL ans = 0;
|
||||
for(int j=0;j<maxn;j++){
|
||||
if((s^j)==j) ans=ans+(cnt[j]*(cnt[j]-1));
|
||||
else ans = ans=ans+cnt[j]*cnt[s^j];
|
||||
}
|
||||
ans=ans/2;
|
||||
if(s==0) ans=ans+n;
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int x, y, w, n;
|
||||
while(cin>>x>>y>>w>>n)
|
||||
{
|
||||
n -= 1;
|
||||
int ans, tmp1, tmp2;
|
||||
if(w > x)
|
||||
ans = (x+y)*n;
|
||||
else
|
||||
{
|
||||
tmp1 = n % ((int)(x/w)+1);
|
||||
tmp2 = n / (x/w+1);
|
||||
ans = tmp2*(x+y)+w*tmp1;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int MAXN=20;
|
||||
const int INF = numeric_limits<int>::max();
|
||||
int dp[1<<MAXN][MAXN];
|
||||
int dis[MAXN][MAXN];
|
||||
int main()
|
||||
{
|
||||
int T,n,m;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=0;i<=n;i++)
|
||||
for(int j=0;j<=n;j++)dis[i][j]=INF;
|
||||
for(int i=0,x,y,w;i<m;i++){
|
||||
scanf("%d%d%d",&x,&y,&w);
|
||||
--x;--y;
|
||||
dis[x][y]=dis[y][x]=min(dis[x][y],w);
|
||||
}
|
||||
if(n==1){
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
for(int k=0;k<n;k++)
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if(dis[i][k]!=INF&&dis[k][j]!=INF)dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
|
||||
}
|
||||
--n;
|
||||
int tot=(1<<n);
|
||||
for(int s=0;s<tot;s++){
|
||||
for(int i=0;i<n;i++){
|
||||
if(s&(1<<i)){
|
||||
if(s==(1<<i))dp[s][i]=dis[0][i+1];
|
||||
else {
|
||||
dp[s][i]=INF;
|
||||
for(int j=0;j<n;j++){
|
||||
if(i!=j&&(s&(1<<j))){
|
||||
dp[s][i]=min(dp[s][i],dp[s^(1<<i)][j]+dis[i+1][j+1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=INF;
|
||||
for(int i=0;i<n;i++)ans=min(ans,dp[tot-1][i]+dis[0][i+1]);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std ;
|
||||
#define LL __int64
|
||||
LL dp[50100] ;
|
||||
int a[50100] ;
|
||||
LL gcd(LL a,LL b) {
|
||||
return b == 0 ? a : gcd(b,a%b) ;
|
||||
}
|
||||
int main() {
|
||||
int t , n , m ;
|
||||
int i , l , r ;
|
||||
LL x , y , temp ;
|
||||
scanf("%d", &t) ;
|
||||
while( t-- ) {
|
||||
scanf("%d %d", &n, &m) ;
|
||||
memset(dp,0,sizeof(dp)) ;
|
||||
for(i = 1 ; i <= n ; i++)
|
||||
scanf("%d", &a[i]) ;
|
||||
while( m-- ) {
|
||||
scanf("%d %d", &l, &r) ;
|
||||
dp[l]++ ;
|
||||
dp[r+1]-- ;
|
||||
}
|
||||
x = 0 ;
|
||||
y = (LL)n*(n-1)*(n-2)/6 ;
|
||||
for(i = 1 ; i <= n ; i++) {
|
||||
dp[i] += dp[i-1] ;
|
||||
if( dp[i] > 2 )
|
||||
x += dp[i]*(dp[i]-1)*(dp[i]-2)/6*a[i] ;
|
||||
}
|
||||
if( x == 0 || y == 0 ) {
|
||||
printf("0\n") ;
|
||||
continue ;
|
||||
}
|
||||
temp = gcd(x,y) ;
|
||||
x /= temp ;
|
||||
y /= temp ;
|
||||
if( y == 1 )
|
||||
printf("%I64d\n", x ) ;
|
||||
else
|
||||
printf("%I64d/%I64d\n", x, y) ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int MAXN=100000+1000;
|
||||
const int MAXM=MAXN*20;
|
||||
const int INF = numeric_limits<int>::max();
|
||||
const LL LL_INF= numeric_limits<LL>::max();
|
||||
struct Edge {
|
||||
int to,next;
|
||||
Edge(){}
|
||||
Edge(int _to,int _next):to(_to),next(_next){}
|
||||
}e[MAXM<<3];
|
||||
int head[MAXM],tot;
|
||||
void init(){
|
||||
memset(head,-1,sizeof(head));
|
||||
tot=0;
|
||||
}
|
||||
void AddEdge(int u,int v){
|
||||
e[tot]=Edge(v,head[u]);
|
||||
head[u]=tot++;
|
||||
}
|
||||
typedef pair<int,int> ii;
|
||||
vector <ii> t[MAXN<<2];
|
||||
int d[MAXN],L[MAXN],R[MAXN],dep[MAXN],ncnt,rid[MAXN],n,Begin[MAXN<<2];
|
||||
void dfs(int u,int d){
|
||||
L[u]=++ncnt;
|
||||
rid[ncnt]=u;
|
||||
dep[u]=d;
|
||||
for(int i=head[u];~i;i=e[i].next)
|
||||
dfs(e[i].to,d+1);
|
||||
R[u]=ncnt;
|
||||
}
|
||||
#define lson L,mid,rt<<1
|
||||
#define rson mid+1,R,rt<<1|1
|
||||
void build(int L,int R,int rt){
|
||||
t[rt].resize(R-L+1);
|
||||
if(L==R){
|
||||
Begin[rt]=n+1;
|
||||
t[rt][0]=make_pair(dep[rid[L]],rid[L]);
|
||||
++n;
|
||||
AddEdge(n,rid[L]);
|
||||
return ;
|
||||
}
|
||||
int mid=(L+R)>>1;
|
||||
build(lson);build(rson);
|
||||
merge(t[rt<<1].begin(),t[rt<<1].end(),t[rt<<1|1].begin(),t[rt<<1|1].end(),t[rt].begin());
|
||||
Begin[rt]=n+1;
|
||||
for(int i=1;i<R-L+1;i++)AddEdge(n+1+i,n+i);
|
||||
for(int i=0;i<R-L+1;i++)AddEdge(n+1+i,t[rt][i].second);
|
||||
n+=R-L+1;
|
||||
}
|
||||
void connect(int L,int R,int rt,int l,int r,int x,int d){
|
||||
if(l<=L&&R<=r){
|
||||
int pos=lower_bound(t[rt].begin(),t[rt].end(),make_pair(d,1<<30))-t[rt].begin()-1;
|
||||
if(~pos)AddEdge(x,Begin[rt]+pos);
|
||||
return ;
|
||||
}
|
||||
int mid=(L+R)>>1;
|
||||
if(l<=mid)connect(lson,l,r,x,d);
|
||||
if(r>mid)connect(rson,l,r,x,d);
|
||||
}
|
||||
int dfn[MAXM],low[MAXM],sta[MAXM],top,times,bleg[MAXM],cnt[MAXM];
|
||||
void tarjan(int u){
|
||||
low[u]=dfn[u]=++times;
|
||||
sta[++top]=u;
|
||||
for(int i=head[u];~i;i=e[i].next){
|
||||
int v=e[i].to;
|
||||
if(!dfn[v]){
|
||||
tarjan(v);
|
||||
low[u]=min(low[u],low[v]);
|
||||
}
|
||||
else if(!bleg[v])
|
||||
low[u]=min(low[u],dfn[v]);
|
||||
}
|
||||
if(dfn[u]==low[u]){
|
||||
bleg[0]++;
|
||||
cnt[bleg[0]]=0;
|
||||
do{
|
||||
bleg[sta[top]]=bleg[0];
|
||||
cnt[bleg[0]]+=(sta[top]<=ncnt);
|
||||
}while(sta[top--]!=u);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d",&n);
|
||||
init();
|
||||
for(int i=2,x;i<=n;i++){
|
||||
scanf("%d",&x);
|
||||
AddEdge(x,i);
|
||||
}
|
||||
ncnt=0;
|
||||
dfs(1,0);
|
||||
init();
|
||||
build(1,ncnt,1);
|
||||
for(int i=1,x,y;i<=ncnt;i++){
|
||||
scanf("%d%d",&x,&y);
|
||||
connect(1,ncnt,1,L[x],R[x],i,dep[x]+y);
|
||||
}
|
||||
memset(dfn,0,sizeof(dfn));
|
||||
memset(bleg,0,sizeof(bleg));
|
||||
top=times=0;
|
||||
for(int i=1;i<=n;i++)if(!dfn[i])tarjan(i);
|
||||
LL ans=0;
|
||||
for(int i=1;i<=bleg[0];i++){
|
||||
ans+=(LL)cnt[i]*(cnt[i]-1)/2;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std ;
|
||||
typedef long long LL ;
|
||||
#define clr( a , x ) memset ( a , x , sizeof a )
|
||||
const int MAXN = 200005 ;
|
||||
struct Palindromic_Tree {
|
||||
int nxt[MAXN][26] ;
|
||||
int fail[MAXN] ;
|
||||
int len[MAXN] ;
|
||||
int S[MAXN] , L , R ;
|
||||
int num[MAXN] ;
|
||||
int last[2] ;
|
||||
int p ;
|
||||
LL tot ;
|
||||
int newnode ( int l ) {
|
||||
for ( int i = 0 ; i < 26 ; ++ i ) nxt[p][i] = 0 ;
|
||||
num[p] = 0 ;
|
||||
len[p] = l ;
|
||||
return p ++ ;
|
||||
}
|
||||
void init ( int n ) {
|
||||
p = 0 ;
|
||||
newnode ( 0 ) ;
|
||||
newnode ( -1 ) ;
|
||||
clr ( S , -1 ) ;
|
||||
L = n ;
|
||||
R = n - 1 ;
|
||||
last[0] = last[1] = 1 ;
|
||||
fail[0] = 1 ;
|
||||
tot = 0 ;
|
||||
}
|
||||
int get_fail ( int v , bool d ) {
|
||||
if ( d ) while ( S[R - len[v] - 1] != S[R] ) v = fail[v] ;
|
||||
else while ( S[L + len[v] + 1] != S[L] ) v = fail[v] ;
|
||||
return v ;
|
||||
}
|
||||
void add ( int c , bool d ) {
|
||||
if ( d ) S[++ R] = c ;
|
||||
else S[-- L] = c ;
|
||||
int cur = get_fail ( last[d] , d ) ;
|
||||
if ( !nxt[cur][c] ) {
|
||||
int now = newnode ( len[cur] + 2 ) ;
|
||||
fail[now] = nxt[get_fail ( fail[cur] , d )][c] ;
|
||||
nxt[cur][c] = now ;
|
||||
num[now] = num[fail[now]] + 1 ;
|
||||
}
|
||||
last[d] = nxt[cur][c] ;
|
||||
if ( len[last[d]] == R - L + 1 ) last[d ^ 1] = last[d] ;
|
||||
tot += num[last[d]] ;
|
||||
}
|
||||
} ;
|
||||
Palindromic_ T ;
|
||||
int n ;
|
||||
void solve () {
|
||||
int op ;
|
||||
char c ;
|
||||
T.init ( n ) ;
|
||||
for ( int i = 0 ; i < n ; ++ i ) {
|
||||
scanf ( "%d" , &op ) ;
|
||||
if ( op <= 2 ) {
|
||||
scanf ( " %c" , &c ) ;
|
||||
T.add ( c - 'a' , op - 1 ) ;
|
||||
}
|
||||
if ( op == 3 ) printf ( "%d\n" , T.p - 2 ) ;
|
||||
if ( op == 4 ) printf ( "%I64d\n" , T.tot ) ;
|
||||
}
|
||||
}
|
||||
int main () {
|
||||
while ( ~scanf ( "%d" , &n ) ) solve () ;
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main(){
|
||||
int n,m,a,b,sign;
|
||||
while(cin>>n>>m){
|
||||
sign=0;
|
||||
while(m--){
|
||||
cin>>a>>b;
|
||||
if((a==1&&b==n)||(b==1&&a==n))
|
||||
sign=1;
|
||||
}
|
||||
n=n*(n-1)/2;
|
||||
if(sign)
|
||||
cout<<"1 "<<n<<endl;
|
||||
else
|
||||
cout<<"1 1"<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int s[1005][1005],sum[1005],dis[1005];
|
||||
int n;
|
||||
void dfs(int x,int num){
|
||||
int i;
|
||||
dis[x]=num;
|
||||
for(i=1;i<=n;i++)
|
||||
if(s[x][i]&&!dis[i])
|
||||
dfs(i,num+1);
|
||||
}
|
||||
int main(){
|
||||
int i,a,b,ans;
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
memset(s,0,sizeof(s));
|
||||
memset(sum,0,sizeof(sum));
|
||||
memset(dis,0,sizeof(dis));
|
||||
for(i=1;i<=n-1;i++){
|
||||
scanf("%d%d",&a,&b);
|
||||
s[a][b]=s[b][a]=1;
|
||||
}
|
||||
dfs(1,1);
|
||||
for(i=1;i<=n;i++)
|
||||
sum[dis[i]]++;
|
||||
ans=0;
|
||||
for(i=1;i<=n;i++){
|
||||
if(sum[i]==1)
|
||||
ans++;
|
||||
else{
|
||||
if(sum[i+1]==0)
|
||||
ans=n;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ans==n)
|
||||
printf("YES\n");
|
||||
else
|
||||
printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
int n,cnt,x,y,deg[1001];
|
||||
bool flag,vis[1001],Map[1001][1001];
|
||||
void dfs(int u)
|
||||
{
|
||||
if(cnt==n) {flag=1;return;}
|
||||
for(int i=1;i<=n&&!flag;++i)
|
||||
if(!vis[i]&&Map[u][i])
|
||||
{
|
||||
vis[i]=1;
|
||||
++cnt;
|
||||
dfs(i);
|
||||
--cnt;
|
||||
vis[i]=0;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
flag=0;
|
||||
cnt=1;
|
||||
memset(deg,0,sizeof(deg));
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(Map,0,sizeof(Map));
|
||||
for(int i=0;i<n;++i){
|
||||
scanf("%d%d",&x,&y);
|
||||
if(x!=y&&!Map[x][y])
|
||||
{
|
||||
Map[x][y]=Map[y][x]=1;
|
||||
++deg[x],++deg[y];
|
||||
}
|
||||
}
|
||||
int s=1,tot=0;
|
||||
for(int i=1;i<=n;++i)
|
||||
if(deg[i]==1) {s=i;++tot;}
|
||||
if(tot>2) {puts("NO");continue;}
|
||||
vis[s]=1;
|
||||
dfs(s);
|
||||
if(flag) puts("YES");
|
||||
else puts("NO");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define MAXN 100005
|
||||
vector<int>vec[MAXN];
|
||||
queue<int>q;
|
||||
int n,d[MAXN];
|
||||
inline double f(double a,double b)
|
||||
{
|
||||
return a * b / (a + b);
|
||||
}
|
||||
double solve()
|
||||
{
|
||||
double ans = 0;
|
||||
for(int i = n - 1;i >= max(n - 100,0);i--)
|
||||
for(int j = n - 1;j > i;j--)
|
||||
ans += f(d[i],d[j]) / (pow(2.0,n - i) - (n + 1) / pow(2.0,i));
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n) != EOF)
|
||||
{
|
||||
for(int i = 0;i <= n;i++)vec[i].clear();
|
||||
for(int i = 1;i < n;i++)
|
||||
{
|
||||
int u;
|
||||
scanf("%d",&u);
|
||||
vec[u - 1].push_back(i);
|
||||
}
|
||||
d[0] = 1;
|
||||
q.push(0);
|
||||
while(!q.empty())
|
||||
{
|
||||
int u = q.front();
|
||||
q.pop();
|
||||
for(int i = 0;i < vec[u].size();i++)
|
||||
{
|
||||
int v = vec[u][i];
|
||||
d[v] = d[u] + 1;
|
||||
q.push(v);
|
||||
}
|
||||
}
|
||||
sort(d,d + n);
|
||||
double ans = solve();
|
||||
printf("%.6f\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
char s[110];
|
||||
int a;
|
||||
}p[1000],t;
|
||||
int T,n;
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&T))
|
||||
{
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
getchar();
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
gets(p[i].s);
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int sum=0;
|
||||
int len=strlen(p[i].s);
|
||||
for(int j=len-4;j<len;j++)
|
||||
{
|
||||
sum*=10;
|
||||
sum+=p[i].s[j]-'0';
|
||||
}
|
||||
p[i].s[len-5]='\0';
|
||||
p[i].a=sum;
|
||||
}
|
||||
for(int i=0;i<n-1;i++)
|
||||
{
|
||||
for(int j=0;j<n-1-i;j++)
|
||||
{
|
||||
if(p[j].a<p[j+1].a)
|
||||
{
|
||||
t=p[j];
|
||||
p[j]=p[j+1];
|
||||
p[j+1]=t;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
printf("%s\n",p[i].s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn=40000;
|
||||
int T;
|
||||
int n;
|
||||
long long a[100],x,cnt;
|
||||
long long vis[maxn];
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
memset(vis,0,sizeof(vis));
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%I64d",&a[i]);
|
||||
cnt=0;
|
||||
for(int i=0;i<n;i++){
|
||||
x=a[i];
|
||||
for(long long j=2;j*j<=x;j++){
|
||||
while(x%j==0){
|
||||
x/=j;
|
||||
vis[cnt++]=j;
|
||||
}
|
||||
}
|
||||
if(x>1)
|
||||
vis[cnt++]=x;
|
||||
}
|
||||
sort(vis,vis+cnt);
|
||||
if(cnt<2)
|
||||
printf("-1\n");
|
||||
else
|
||||
printf("%I64d\n",vis[0]*vis[1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,309 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
#define DIGIT 4
|
||||
#define DEPTH 10000
|
||||
#define MAX 100
|
||||
typedef int bignum_t[MAX+1];
|
||||
int read(bignum_ a,istream& is=cin){
|
||||
char buf[MAX*DIGIT+1],ch;
|
||||
int i,j;
|
||||
memset((void*)a,0,sizeof(bignum_t));
|
||||
if (!(is>>buf)) return 0;
|
||||
for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
|
||||
ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
|
||||
for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
|
||||
for (i=1;i<=a[0];i++)
|
||||
for (a[i]=0,j=0;j<DIGIT;j++)
|
||||
a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
return 1;
|
||||
}
|
||||
void write(const bignum_ a,ostream& os=cout){
|
||||
int i,j;
|
||||
for (os<<a[i=a[0]],i--;i;i--)
|
||||
for (j=DEPTH/10;j;j/=10)
|
||||
os<<a[i]/j%10;
|
||||
}
|
||||
int comp(const bignum_ a,const bignum_ b){
|
||||
int i;
|
||||
if (a[0]!=b[0])
|
||||
return a[0]-b[0];
|
||||
for (i=a[0];i;i--)
|
||||
if (a[i]!=b[i])
|
||||
return a[i]-b[i];
|
||||
return 0;
|
||||
}
|
||||
int comp(const bignum_ a,const int b){
|
||||
int c[12]={1};
|
||||
for (c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
|
||||
return comp(a,c);
|
||||
}
|
||||
int comp(const bignum_ a,const int c,const int d,const bignum_ b){
|
||||
int i,t=0,O=-DEPTH*2;
|
||||
if (b[0]-a[0]<d&&c)
|
||||
return 1;
|
||||
for (i=b[0];i>d;i--){
|
||||
t=t*DEPTH+a[i-d]*c-b[i];
|
||||
if (t>0) return 1;
|
||||
if (t<O) return 0;
|
||||
}
|
||||
for (i=d;i;i--){
|
||||
t=t*DEPTH-b[i];
|
||||
if (t>0) return 1;
|
||||
if (t<O) return 0;
|
||||
}
|
||||
return t>0;
|
||||
}
|
||||
void add(bignum_ a,const bignum_ b){
|
||||
int i;
|
||||
for (i=1;i<=b[0];i++)
|
||||
if ((a[i]+=b[i])>=DEPTH)
|
||||
a[i]-=DEPTH,a[i+1]++;
|
||||
if (b[0]>=a[0])
|
||||
a[0]=b[0];
|
||||
else
|
||||
for (;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
|
||||
a[0]+=(a[a[0]+1]>0);
|
||||
}
|
||||
void add(bignum_ a,const int b){
|
||||
int i=1;
|
||||
for (a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
|
||||
for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
|
||||
}
|
||||
void sub(bignum_ a,const bignum_ b){
|
||||
int i;
|
||||
for (i=1;i<=b[0];i++)
|
||||
if ((a[i]-=b[i])<0)
|
||||
a[i+1]--,a[i]+=DEPTH;
|
||||
for (;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
}
|
||||
void sub(bignum_ a,const int b){
|
||||
int i=1;
|
||||
for (a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
}
|
||||
void sub(bignum_ a,const bignum_ b,const int c,const int d){
|
||||
int i,O=b[0]+d;
|
||||
for (i=1+d;i<=O;i++)
|
||||
if ((a[i]-=b[i-d]*c)<0)
|
||||
a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH;
|
||||
for (;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
}
|
||||
void mul(bignum_ c,const bignum_ a,const bignum_ b){
|
||||
int i,j;
|
||||
memset((void*)c,0,sizeof(bignum_t));
|
||||
for (c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
|
||||
for (j=1;j<=b[0];j++)
|
||||
if ((c[i+j-1]+=a[i]*b[j])>=DEPTH)
|
||||
c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH;
|
||||
for (c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
|
||||
}
|
||||
void mul(bignum_ a,const int b){
|
||||
int i;
|
||||
for (a[1]*=b,i=2;i<=a[0];i++){
|
||||
a[i]*=b;
|
||||
if (a[i-1]>=DEPTH)
|
||||
a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH;
|
||||
}
|
||||
for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
}
|
||||
void mul(bignum_ b,const bignum_ a,const int c,const int d){
|
||||
int i;
|
||||
memset((void*)b,0,sizeof(bignum_t));
|
||||
for (b[0]=a[0]+d,i=d+1;i<=b[0];i++)
|
||||
if ((b[i]+=a[i-d]*c)>=DEPTH)
|
||||
b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH;
|
||||
for (;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
|
||||
for (;!b[b[0]]&&b[0]>1;b[0]--);
|
||||
}
|
||||
void div(bignum_ c,bignum_ a,const bignum_ b){
|
||||
int h,l,m,i;
|
||||
memset((void*)c,0,sizeof(bignum_t));
|
||||
c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1;
|
||||
for (i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
|
||||
for (h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
|
||||
if (comp(b,m,i-1,a)) h=m-1;
|
||||
else l=m;
|
||||
for (;!c[c[0]]&&c[0]>1;c[0]--);
|
||||
c[0]=c[0]>1?c[0]:1;
|
||||
}
|
||||
void div(bignum_ a,const int b,int& c){
|
||||
int i;
|
||||
for (c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
}
|
||||
void sqrt(bignum_ b,bignum_ a){
|
||||
int h,l,m,i;
|
||||
memset((void*)b,0,sizeof(bignum_t));
|
||||
for (i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
|
||||
for (h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
|
||||
if (comp(b,m,i-1,a)) h=m-1;
|
||||
else l=m;
|
||||
for (;!b[b[0]]&&b[0]>1;b[0]--);
|
||||
for (i=1;i<=b[0];b[i++]>>=1);
|
||||
}
|
||||
int length(const bignum_ a){
|
||||
int t,ret;
|
||||
for (ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);
|
||||
return ret>0?ret:1;
|
||||
}
|
||||
int digit(const bignum_ a,const int b){
|
||||
int i,ret;
|
||||
for (ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
|
||||
return ret%10;
|
||||
}
|
||||
int zeronum(const bignum_ a){
|
||||
int ret,t;
|
||||
for (ret=0;!a[ret+1];ret++);
|
||||
for (t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);
|
||||
return ret;
|
||||
}
|
||||
void comp(int* a,const int l,const int h,const int d){
|
||||
int i,j,t;
|
||||
for (i=l;i<=h;i++)
|
||||
for (t=i,j=2;t>1;j++)
|
||||
while (!(t%j))
|
||||
a[j]+=d,t/=j;
|
||||
}
|
||||
void convert(int* a,const int h,bignum_ b){
|
||||
int i,j,t=1;
|
||||
memset(b,0,sizeof(bignum_t));
|
||||
for (b[0]=b[1]=1,i=2;i<=h;i++)
|
||||
if (a[i])
|
||||
for (j=a[i];j;t*=i,j--)
|
||||
if (t*i>DEPTH)
|
||||
mul(b,t),t=1;
|
||||
mul(b,t);
|
||||
}
|
||||
void combination(bignum_ a,int m,int n){
|
||||
int* t=new int[m+1];
|
||||
memset((void*)t,0,sizeof(int)*(m+1));
|
||||
comp(t,n+1,m,1);
|
||||
comp(t,2,m-n,-1);
|
||||
convert(t,m,a);
|
||||
delete []t;
|
||||
}
|
||||
void permutation(bignum_ a,int m,int n){
|
||||
int i,t=1;
|
||||
memset(a,0,sizeof(bignum_t));
|
||||
a[0]=a[1]=1;
|
||||
for (i=m-n+1;i<=m;t*=i++)
|
||||
if (t*i>DEPTH)
|
||||
mul(a,t),t=1;
|
||||
mul(a,t);
|
||||
}
|
||||
#define SGN(x) ((x)>0?1:((x)<0?-1:0))
|
||||
#define ABS(x) ((x)>0?(x):-(x))
|
||||
int read(bignum_ a,int &sgn,istream& is=cin){
|
||||
char str[MAX*DIGIT+2],ch,*buf;
|
||||
int i,j;
|
||||
memset((void*)a,0,sizeof(bignum_t));
|
||||
if (!(is>>str)) return 0;
|
||||
buf=str,sgn=1;
|
||||
if (*buf=='-') sgn=-1,buf++;
|
||||
for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
|
||||
ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
|
||||
for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
|
||||
for (i=1;i<=a[0];i++)
|
||||
for (a[i]=0,j=0;j<DIGIT;j++)
|
||||
a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
|
||||
for (;!a[a[0]]&&a[0]>1;a[0]--);
|
||||
if (a[0]==1&&!a[1]) sgn=0;
|
||||
return 1;
|
||||
}
|
||||
struct bignum{
|
||||
bignum_t num;
|
||||
int sgn;
|
||||
public:
|
||||
inline bignum(){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=0;}
|
||||
inline bignum& operator=(const bignum& a){memcpy(num,a.num,sizeof(bignum_t));sgn=a.sgn;return *this;}
|
||||
inline bignum& operator=(const int a){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=SGN(a);add(num,sgn*a);return *this;};
|
||||
inline bignum& operator+=(const bignum& a){if(sgn==a.sgn)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t;
|
||||
memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=a.sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn;return *this;}
|
||||
inline bignum& operator+=(const int a){if(sgn*a>0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t;
|
||||
memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sgn=-sgn;sub(num,t);}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=SGN(a),add(num,ABS(a));return *this;}
|
||||
inline bignum operator+(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
|
||||
inline bignum operator+(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
|
||||
inline bignum& operator-=(const bignum& a){if(sgn*a.sgn<0)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t;
|
||||
memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)add(num,a.num),sgn=-a.sgn;return *this;}
|
||||
inline bignum& operator-=(const int a){if(sgn*a<0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t;
|
||||
memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=-SGN(a),add(num,ABS(a));return *this;}
|
||||
inline bignum operator-(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
|
||||
inline bignum operator-(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
|
||||
inline bignum& operator*=(const bignum& a){bignum_ t;mul(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn*=a.sgn;return *this;}
|
||||
inline bignum& operator*=(const int a){mul(num,ABS(a));sgn*=SGN(a);return *this;}
|
||||
inline bignum operator*(const bignum& a){bignum ret;mul(ret.num,num,a.num);ret.sgn=sgn*a.sgn;return ret;}
|
||||
inline bignum operator*(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));mul(ret.num,ABS(a));ret.sgn=sgn*SGN(a);return ret;}
|
||||
inline bignum& operator/=(const bignum& a){bignum_ t;div(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn;return *this;}
|
||||
inline bignum& operator/=(const int a){int t;div(num,ABS(a),t);sgn=(num[0]==1&&!num[1])?0:sgn*SGN(a);return *this;}
|
||||
inline bignum operator/(const bignum& a){bignum ret;bignum_ t;memcpy(t,num,sizeof(bignum_t));div(ret.num,t,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn;return ret;}
|
||||
inline bignum operator/(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);return ret;}
|
||||
inline bignum& operator%=(const bignum& a){bignum_ t;div(t,num,a.num);if (num[0]==1&&!num[1])sgn=0;return *this;}
|
||||
inline int operator%=(const int a){int t;div(num,ABS(a),t);memset(num,0,sizeof(bignum_t));num[0]=1;add(num,t);return t;}
|
||||
inline bignum operator%(const bignum& a){bignum ret;bignum_ t;memcpy(ret.num,num,sizeof(bignum_t));div(t,ret.num,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn;return ret;}
|
||||
inline int operator%(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);memset(ret.num,0,sizeof(bignum_t));ret.num[0]=1;add(ret.num,t);return t;}
|
||||
inline bignum& operator++(){*this+=1;return *this;}
|
||||
inline bignum& operator--(){*this-=1;return *this;};
|
||||
inline int operator>(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);}
|
||||
inline int operator>(const int a){return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);}
|
||||
inline int operator>=(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);}
|
||||
inline int operator>=(const int a){return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);}
|
||||
inline int operator<(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);}
|
||||
inline int operator<(const int a){return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);}
|
||||
inline int operator<=(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);}
|
||||
inline int operator<=(const int a){return sgn<0?(a<0?comp(num,-a)>=0:1):(sgn>0?(a>0?comp(num,a)<=0:0):a>=0);}
|
||||
inline int operator==(const bignum& a){return (sgn==a.sgn)?!comp(num,a.num):0;}
|
||||
inline int operator==(const int a){return (sgn*a>=0)?!comp(num,ABS(a)):0;}
|
||||
inline int operator!=(const bignum& a){return (sgn==a.sgn)?comp(num,a.num):1;}
|
||||
inline int operator!=(const int a){return (sgn*a>=0)?comp(num,ABS(a)):1;}
|
||||
inline int operator[](const int a){return digit(num,a);}
|
||||
friend inline istream& operator>>(istream& is,bignum& a){read(a.num,a.sgn,is);return is;}
|
||||
friend inline ostream& operator<<(ostream& os,const bignum& a){if(a.sgn<0)os<<'-';write(a.num,os);return os;}
|
||||
friend inline bignum sqrt(const bignum& a){bignum ret;bignum_ t;memcpy(t,a.num,sizeof(bignum_t));sqrt(ret.num,t);ret.sgn=ret.num[0]!=1||ret.num[1];return ret;}
|
||||
friend inline bignum sqrt(const bignum& a,bignum& b){bignum ret;memcpy(b.num,a.num,sizeof(bignum_t));sqrt(ret.num,b.num);ret.sgn=ret.num[0]!=1||ret.num[1];b.sgn=b.num[0]!=1||ret.num[1];return ret;}
|
||||
inline int length(){return ::length(num);}
|
||||
inline int zeronum(){return ::zeronum(num);}
|
||||
inline bignum C(const int m,const int n){combination(num,m,n);sgn=1;return *this;}
|
||||
inline bignum P(const int m,const int n){permutation(num,m,n);sgn=1;return *this;}
|
||||
};
|
||||
#define N 105
|
||||
bignum s[N];
|
||||
int main()
|
||||
{
|
||||
int t,n,i,k;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=k=0;i<n;i++)
|
||||
{
|
||||
cin>>s[i];
|
||||
if(s[i]==0)
|
||||
k++;
|
||||
}
|
||||
if(k>0&&k<n)
|
||||
{
|
||||
puts("No");
|
||||
continue;
|
||||
}
|
||||
if(n<3)
|
||||
{
|
||||
puts("Yes");
|
||||
continue;
|
||||
}
|
||||
for(i=1;i<n-1;i++)
|
||||
if(s[i-1]*s[i+1]!=s[i]*s[i])
|
||||
break;
|
||||
if(i<n-1)
|
||||
puts("No");
|
||||
else
|
||||
puts("Yes");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include<stdio.h>
|
||||
#define LL long long
|
||||
LL fun(LL m)
|
||||
{
|
||||
LL res=m;
|
||||
for(LL i=2;i*i<=m;i++)
|
||||
{
|
||||
if(m%i==0)
|
||||
{
|
||||
res=(res*(i-1))/i;
|
||||
while(m%i==0)
|
||||
{
|
||||
m/=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(m>1) res=(res*(m-1))/m;
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL n;
|
||||
int T;
|
||||
scanf ("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%lld",&n);
|
||||
printf("%lld\n",fun(n+1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
char str[20010];
|
||||
int bits[32];
|
||||
int save[32][20010];
|
||||
int tmp[32];
|
||||
int findindex(int i,int key){
|
||||
int l=1,r=save[i][0];
|
||||
int m,ans=0;
|
||||
while(l<=r){
|
||||
int m=(l+r)/2;
|
||||
if(save[i][m]<=key){
|
||||
ans=m;
|
||||
l=m+1;
|
||||
}
|
||||
else r=m-1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main(){
|
||||
int kase,now,T,K;
|
||||
scanf("%d",&kase);
|
||||
for(int i=1;i<32;i++) bits[i]=(1<<i);
|
||||
while(kase--){
|
||||
scanf("%s",str);
|
||||
int len=strlen(str);
|
||||
for(int i=0;i<31;i++) save[i][0]=0;
|
||||
for(int i=0;i<len;i++){
|
||||
now=0;
|
||||
for(int j=i;j<=min(i+29,len-1);j++){
|
||||
now=(now<<1)+(str[j]-'A');
|
||||
save[j-i+1][++save[j-i+1][0]]=now;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=30;i++) sort(save[i]+1,save[i]+save[i][0]+1);
|
||||
for(int i=1;i<=30;i++) {
|
||||
save[i][0]=unique(save[i]+1,save[i]+save[i][0]+1)-(save[i]+1);
|
||||
}
|
||||
scanf("%d",&T); int ans,ansbit;
|
||||
while(T--){
|
||||
scanf("%d",&K);
|
||||
ans=-1;
|
||||
for(int i=1;i<=30;i++){
|
||||
if(K>bits[i]-save[i][0]){
|
||||
K-=(bits[i]-save[i][0]);
|
||||
continue;
|
||||
}
|
||||
int l=0,r=bits[i]-1;
|
||||
while(l<=r){
|
||||
int m=(l+r)>>1;
|
||||
int pos=findindex(i,m);
|
||||
if(K>m+1-pos) l=m+1;
|
||||
else if(K<m+1-pos) r=m-1;
|
||||
else{
|
||||
ans=m;
|
||||
while(ans==save[i][pos]&&pos!=0){
|
||||
ans--; pos--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ans!=-1){
|
||||
ansbit=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
int cnt=0;
|
||||
while(ansbit--){
|
||||
tmp[cnt++]=ans%2;
|
||||
ans/=2;
|
||||
}
|
||||
while(cnt--)
|
||||
printf("%c",tmp[cnt]+'A');
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include<map>
|
||||
#include<set>
|
||||
#include<cmath>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<cstdio>
|
||||
#include<cctype>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<functional>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int, int> PII;
|
||||
const int MX = 1e5 + 5;
|
||||
double A[MX], B[MX];
|
||||
int main() {
|
||||
int T, n;
|
||||
scanf("%d", &T);
|
||||
while(T--) {
|
||||
scanf("%d", &n);
|
||||
for(int i = 1; i <= n; i++) {
|
||||
scanf("%lf", &A[i]);
|
||||
}
|
||||
for(int i = 1; i <= n; i++) {
|
||||
scanf("%lf", &B[i]);
|
||||
}
|
||||
double L = 0, R = 1000, m;
|
||||
for(int i = 1; i <= 40; i++) {
|
||||
m = (L + R) / 2;
|
||||
double s, sum1 = 0, sum2 = 0;
|
||||
for(int j = 1; j <= n; j++) {
|
||||
if(A[j] <= m) s = 0;
|
||||
else s = B[j] * B[j] * (A[j] - m) * (A[j] - m) * (A[j] - m) / (3.0 * A[j] * A[j]);
|
||||
sum1 += s;
|
||||
sum2 += B[j] * B[j] * A[j] / 3.0 - s;
|
||||
}
|
||||
if(sum1 < sum2) R = m;
|
||||
else L = m;
|
||||
}
|
||||
printf("%d\n", (int)m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 55;
|
||||
const double eps = 1e-6;
|
||||
const double inf = 1e20;
|
||||
const int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
|
||||
int N, M, K, Sx, Sy, Ex, Ey;
|
||||
bool done[maxn][maxn][maxn];
|
||||
char G[maxn][maxn];
|
||||
double dp[maxn][maxn][maxn];
|
||||
struct State {
|
||||
int x, y, k;
|
||||
double d;
|
||||
State(int x = 0, int y = 0, int k = 0, double d = 0): x(x), y(y), k(k), d(d) {}
|
||||
bool operator < (const State& u) const { return d > u.d; }
|
||||
};
|
||||
void init () {
|
||||
scanf("%d%d%d", &N, &M, &K);
|
||||
for (int i = 1; i <= N; i++)
|
||||
scanf("%s", G[i]+1);
|
||||
scanf("%d%d%d%d", &Sx, &Sy, &Ex, &Ey);
|
||||
}
|
||||
bool Dijkstra () {
|
||||
for (int i = 1; i <= N; i++)
|
||||
for (int j = 1; j <= M; j++)
|
||||
for (int k = 0; k <= K; k++) dp[i][j][k] = inf;
|
||||
memset(done, false, sizeof(done));
|
||||
dp[Sx][Sy][K] = 0;
|
||||
priority_queue<State> Q;
|
||||
Q.push(State(Sx, Sy, K, 0));
|
||||
while (!Q.empty()) {
|
||||
State u = Q.top();
|
||||
Q.pop();
|
||||
int x = u.x, y = u.y, k = u.k;
|
||||
if (done[x][y][k]) continue;
|
||||
done[x][y][k] = true;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int p = x + dir[i][0];
|
||||
int q = y + dir[i][1];
|
||||
int t = k - 1;
|
||||
if (p <= 0 || p > N || q <= 0 || q > M || t <= 0 || G[p][q] == '#') continue;
|
||||
double d = 1.0 * abs(G[x][y] - G[p][q]) / k;
|
||||
if (dp[p][q][t] > dp[x][y][k] + d) {
|
||||
dp[p][q][t] = dp[x][y][k] + d;
|
||||
Q.push(State(p, q, t, dp[p][q][t]));
|
||||
}
|
||||
}
|
||||
}
|
||||
double ans = inf;
|
||||
for (int i = 1; i <= K; i++)
|
||||
ans = min(ans, dp[Ex][Ey][i]);
|
||||
if (fabs(ans-inf) < eps) return false;
|
||||
printf("%.2lf\n", ans);
|
||||
return true;
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
while (cas--) {
|
||||
init();
|
||||
if (!Dijkstra()) printf("No Answer\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include<map>
|
||||
#include<set>
|
||||
#include<cmath>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<cstdio>
|
||||
#include<cctype>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<functional>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int matMX = 128 + 5;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const LL mod = 1e9 + 7;
|
||||
struct Mat {
|
||||
int m, n;
|
||||
LL S[matMX][matMX];
|
||||
Mat(int a, int b) {
|
||||
m = a;
|
||||
n = b;
|
||||
memset(S, 0, sizeof(S));
|
||||
}
|
||||
Mat(int a, int b, LL w[][matMX]) {
|
||||
m = a;
|
||||
n = b;
|
||||
for(int i = 0; i < m; i++) {
|
||||
for(int j = 0; j < n; j++) {
|
||||
S[i][j] = w[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
Mat mat_mul(Mat A, Mat B) {
|
||||
Mat C(A.m, B.n);
|
||||
for(int i = 0; i < A.m; i++) {
|
||||
for(int j = 0; j < B.n; j++) {
|
||||
for(int k = 0; k < A.n; k++) {
|
||||
C.S[i][j] = (C.S[i][j] + A.S[i][k] * B.S[k][j]) % mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
return C;
|
||||
}
|
||||
Mat Blank(int m, int n) {
|
||||
Mat ret(m, n);
|
||||
for(int i = 0; i < m; i++) {
|
||||
ret.S[i][i] = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
Mat mat_pow(Mat A, LL b) {
|
||||
Mat ret = Blank(A.m, A.n);
|
||||
while(b) {
|
||||
if(b & 1) ret = mat_mul(ret, A);
|
||||
A = mat_mul(A, A);
|
||||
b >>= 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
LL S[matMX][matMX];
|
||||
void DFS(int m, int cnt, int x, int y) {
|
||||
if(cnt == m) {
|
||||
S[x][y] = 1;
|
||||
return;
|
||||
}
|
||||
DFS(m, cnt + 1, x << 1, y << 1);
|
||||
DFS(m, cnt + 1, x << 1 | 1, y << 1 | 1);
|
||||
if(cnt) {
|
||||
if((x & 1) ^ (y & 1) == 0) {
|
||||
DFS(m, cnt + 1, x << 1, y << 1 | 1);
|
||||
DFS(m, cnt + 1, x << 1 | 1, y << 1);
|
||||
} else if((x & 1) && !(y & 1)) {
|
||||
DFS(m, cnt + 1, x << 1 | 1, y << 1);
|
||||
} else {
|
||||
DFS(m, cnt + 1, x << 1, y << 1 | 1);
|
||||
}
|
||||
} else {
|
||||
DFS(m, cnt + 1, x << 1 | 1, y << 1);
|
||||
DFS(m, cnt + 1, x << 1, y << 1 | 1);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int m, n;
|
||||
while(~scanf("%d%d", &n, &m)) {
|
||||
DFS(m, 0, 0, 0);
|
||||
Mat A(1 << m, 1 << m, S), B(1 << m, 1);
|
||||
memset(B.S, 0, sizeof(B.S));
|
||||
B.S[0][0] = 1;
|
||||
Mat ret = mat_mul(mat_pow(A, n), B);
|
||||
LL ans = 0;
|
||||
for(int i = 0; i < (1 << m); i++) {
|
||||
ans += ret.S[i][0];
|
||||
ans %= mod;
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <cstdio>
|
||||
#include <ctime>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define getmid(l,r) ((l) + ((r) - (l)) / 2)
|
||||
#define MEM(a,b) memset(a,b,sizeof(a))
|
||||
#define MP(a,b) make_pair(a,b)
|
||||
#define PB push_back
|
||||
typedef long long ll;
|
||||
typedef pair<int,int> pii;
|
||||
const double eps = 1e-8;
|
||||
const int INF = (1 << 30) - 1;
|
||||
const int MAXN = 100010;
|
||||
const ll mod = 1e9 + 7;
|
||||
int T,LA,LB;
|
||||
char A[MAXN],B[MAXN];
|
||||
int dp[100010][16];
|
||||
int Solve(char *s,int L,int p,int f,int xsum){
|
||||
if(p > L) return xsum;
|
||||
if(f){
|
||||
int len = L - p + 1;
|
||||
int res = 0;
|
||||
for(int i = 0; i < 16; ++i)
|
||||
res = (res + 1ll * (xsum ^ i) * dp[len][i]) % mod;
|
||||
return res;
|
||||
}
|
||||
int top = s[p] - '0';
|
||||
int res = 0;
|
||||
for(int i = 0; i <= top; ++i)
|
||||
res = (res + 1ll * Solve(s,L,p + 1,f | (i < top),xsum ^ i)) % mod;
|
||||
return res;
|
||||
}
|
||||
void Pre(){
|
||||
dp[0][0] = 1;
|
||||
for(int i = 1; i < 100010; ++i)
|
||||
for(int j = 0; j < 16; ++j)
|
||||
for(int k = 0; k < 10; ++k)
|
||||
dp[i][j] = (dp[i][j] + 1ll * dp[i - 1][j ^ k]) % mod;
|
||||
}
|
||||
int main(){
|
||||
Pre();
|
||||
scanf("%d",&T);
|
||||
for(int tt = 1; tt <= T; ++tt){
|
||||
scanf("%s%s",A + 1,B + 1);
|
||||
LA = strlen(A + 1);
|
||||
LB = strlen(B + 1);
|
||||
int tmp = 0;
|
||||
for(int i = 1; i <= LA; ++i) tmp ^= (A[i] - '0');
|
||||
int ansA = Solve(A,LA,1,0,0);
|
||||
int ansB = Solve(B,LB,1,0,0);
|
||||
printf("Case #%d: %d\n",tt,(int)
|
||||
(((1ll * ansB - ansA + tmp) % mod + mod) % mod));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#define maxn 150005
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
char name[205];
|
||||
int v, tp;
|
||||
friend bool operator <(node a,node b)
|
||||
{
|
||||
if(a.v == b.v) return a.tp > b.tp;
|
||||
return a.v < b.v;
|
||||
}
|
||||
};
|
||||
node fri[maxn];
|
||||
struct node1
|
||||
{
|
||||
int t, r;
|
||||
}ask[maxn];
|
||||
bool cmp(node1 a, node1 b)
|
||||
{
|
||||
return a.t < b.t;
|
||||
}
|
||||
int put[maxn], wen[105];
|
||||
int main()
|
||||
{
|
||||
int t, k, m, p, i, j, ok, now;
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %d %d", &k, &m, &p);
|
||||
for(i = 0;i < k;i++)
|
||||
{
|
||||
scanf("%s %d",fri[i].name, &fri[i].v);
|
||||
fri[i].tp = i;
|
||||
}
|
||||
ask[0].t = -1;
|
||||
for(i = 0;i < m;i++)
|
||||
scanf("%d %d", &ask[i].t, &ask[i].r);
|
||||
for(i = 0;i < p;i++)
|
||||
scanf("%d", &wen[i]);
|
||||
priority_queue<node>q;
|
||||
sort(ask, ask + m, cmp);
|
||||
now = 0;
|
||||
ok = 0;
|
||||
for(i = 1;i <= k;i++)
|
||||
{
|
||||
q.push(fri[i - 1]);
|
||||
if(i == ask[now].t)
|
||||
{
|
||||
for(j = 1;j <= ask[now].r&&(!q.empty());j++)
|
||||
{
|
||||
node x = q.top();
|
||||
q.pop();
|
||||
put[ok++] = x.tp;
|
||||
}
|
||||
now++;
|
||||
}
|
||||
}
|
||||
while(!q.empty())
|
||||
{
|
||||
node x = q.top();
|
||||
q.pop();
|
||||
put[ok++] = x.tp;
|
||||
}
|
||||
for(i = 0;i < p;i++)
|
||||
printf("%s%c", fri[put[wen[i] - 1]].name, i==p-1?'\n':' ');
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define pr(x) cout << #x << " = " << x << " "
|
||||
#define prln(x) cout << #x << " = " << x << endl
|
||||
const int N = 1e4 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
|
||||
const int M = 1e5 + 10;
|
||||
int n, m;
|
||||
int deg[N], val[N];
|
||||
vector<int> G[N];
|
||||
bool vis[N];
|
||||
void dfs(int u, int &cnt, long long& sum) {
|
||||
sum += val[u];
|
||||
++cnt;
|
||||
vis[u] = true;
|
||||
for(int i = 0; i < G[u].size(); ++i) {
|
||||
int v = G[u][i];
|
||||
if(vis[v]) continue;
|
||||
dfs(v, cnt, sum);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
ios_base::sync_with_stdio(0);
|
||||
int t; scanf("%d", &t);
|
||||
while(t--) {
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i = 1; i <= n; ++i) {
|
||||
scanf("%d", val + i);
|
||||
G[i].clear();
|
||||
vis[i] = false;
|
||||
deg[i] = 0;
|
||||
}
|
||||
for(int i = 1; i <= m; ++i) {
|
||||
int u, v; scanf("%d%d", &u, &v);
|
||||
G[u].push_back(v);
|
||||
G[v].push_back(u);
|
||||
++deg[u], ++deg[v];
|
||||
}
|
||||
queue<int> q;
|
||||
for(int i = 1; i <= n; ++i)
|
||||
if(deg[i] < 2) q.push(i);
|
||||
while(q.size()) {
|
||||
int u = q.front(); q.pop();
|
||||
deg[u] = 0; vis[u] = true;
|
||||
for(int i = 0; i < G[u].size(); ++i) {
|
||||
int v = G[u][i];
|
||||
if(--deg[v] < 2 && !vis[v]) q.push(v);
|
||||
}
|
||||
}
|
||||
long long ans = 0;
|
||||
for(int i = 1; i <= n; ++i) {
|
||||
if(vis[i]) continue;
|
||||
int cnt = 0; long long sum = 0;
|
||||
dfs(i, cnt, sum);
|
||||
if(cnt & 1) ans += sum;
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int MOD = (int)1e9+7;
|
||||
const int INF = (int)1e9;
|
||||
const int MAXN = 438744;
|
||||
int a[MAXN+5];
|
||||
int b[MAXN+5];
|
||||
int sum[MAXN+5];
|
||||
int dp[MAXN+5];
|
||||
int pre[MAXN+5];
|
||||
int sz,val;
|
||||
int add(int x,int y){
|
||||
x+=y;
|
||||
if(x>=MOD)x-=MOD;
|
||||
return x;
|
||||
}
|
||||
int po(int x,int n){
|
||||
int ans=1;
|
||||
int temp=x;
|
||||
while(n){
|
||||
if(n&1)ans=(ll)ans*temp%MOD;
|
||||
temp=(ll)temp*temp%MOD;
|
||||
n>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
val=po(2,MOD-2);
|
||||
a[1]=1;
|
||||
a[2]=2;
|
||||
a[3]=2;
|
||||
int sz=3;
|
||||
for(int i=3;;i++){
|
||||
int cnt=a[i];
|
||||
while(cnt){
|
||||
a[++sz]=i;
|
||||
cnt--;
|
||||
if(sz>=MAXN)break;
|
||||
}
|
||||
if(sz>=MAXN)break;
|
||||
}
|
||||
for(int i=1;i<=MAXN;i++){
|
||||
sum[i]=sum[i-1]+a[i];
|
||||
if(sum[i]>=INF)break;
|
||||
}
|
||||
for(int i=1;i<=MAXN;i++){
|
||||
dp[i]=add(dp[i-1],(ll)( add(add(add(pre[i-1],1),pre[i-1]),a[i]) )*a[i]%MOD*i%MOD*val%MOD);
|
||||
pre[i]=add(pre[i-1],a[i]);
|
||||
}
|
||||
int t;scanf("%d",&t);
|
||||
while(t--){
|
||||
int n;scanf("%d",&n);
|
||||
int l=1,r=MAXN;
|
||||
int pos;
|
||||
while(l<=r){
|
||||
int mid=l+r>>1;
|
||||
if(n<=sum[mid]){
|
||||
pos=mid;
|
||||
r=mid-1;
|
||||
}
|
||||
else l=mid+1;
|
||||
}
|
||||
int x=n-sum[pos-1];
|
||||
int ans=add(dp[pos-1],(ll)( add(add(add(pre[pos-1],1),pre[pos-1]),x) )*x%MOD*pos%MOD*val%MOD);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn = 1 * 1e5 + 5;
|
||||
ll S;
|
||||
int N, M, L[10], X[10], head, rear, ans;
|
||||
map<ll, int> C;
|
||||
set<ll> T;
|
||||
struct State {
|
||||
ll s;
|
||||
int f, c;
|
||||
State(ll s = 0, int f = 0, int c = 0): s(s), f(f), c(c) {}
|
||||
}Q[maxn], cur;
|
||||
inline ll idx(int* c) {
|
||||
ll ret = 0;
|
||||
for (int i = 0; i < 12; i++)
|
||||
ret = ret * (N+1) + c[i];
|
||||
return ret;
|
||||
}
|
||||
inline void reidx(ll s, int* c) {
|
||||
for (int i = 11; i >= 0; i--) {
|
||||
c[i] = s % (N+1);
|
||||
s /= (N+1);
|
||||
}
|
||||
}
|
||||
void init () {
|
||||
C.clear();
|
||||
T.clear();
|
||||
scanf("%d%d", &N, &M);
|
||||
int x, cnt[15];
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
for (int i = 1; i <= N; i++) {
|
||||
scanf("%d", &x);
|
||||
if (x == 12) x = 0;
|
||||
cnt[x]++;
|
||||
}
|
||||
S = idx(cnt);
|
||||
for (int i = 0; i < M; i++)
|
||||
scanf("%d%d", &L[i], &X[i]);
|
||||
}
|
||||
bool dfs1 (int d, int* c, int* t, int n, int m, int v) {
|
||||
if (d > 12 || n > m) return false;
|
||||
if (n == 0 && m == 0) {
|
||||
ll tmp = idx(t);
|
||||
if (tmp == S) {
|
||||
ans = cur.c + 1;
|
||||
return true;
|
||||
}
|
||||
if (!C.count(tmp)) {
|
||||
C[tmp] = cur.c + 1;
|
||||
if (cur.c < 4) Q[rear++] = State(tmp, v, cur.c+1);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
for (int i = min(c[d], n); i >= 0; i--) {
|
||||
if (n-i > m-c[d]) break;
|
||||
t[(d-X[v]+12)%12] += i;
|
||||
t[d] += (c[d] - i);
|
||||
if (dfs1(d+1, c, t, n-i, m-c[d], v)) return true;
|
||||
t[(d-X[v]+12)%12] -= i;
|
||||
t[d] -= (c[d] - i);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool dfs2 (int d, int* c, int* t, int n, int m, int v) {
|
||||
if (d > 12 || n > m) return false;
|
||||
if (n == 0 && m == 0) {
|
||||
ll tmp = idx(t);
|
||||
if (C.count(tmp)) {
|
||||
ans = C[tmp] + cur.c + 1;
|
||||
return true;
|
||||
}
|
||||
if (!T.count(tmp) && cur.c < 2) {
|
||||
T.insert(tmp);
|
||||
Q[rear++] = State(tmp, v, cur.c+1);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
for (int i = min(c[d], n); i >= 0; i--) {
|
||||
if (n-i > m-c[d]) break;
|
||||
t[(d+X[v]+12)%12] += i;
|
||||
t[d] += (c[d] - i);
|
||||
if (dfs2(d+1, c, t, n-i, m-c[d], v)) return true;
|
||||
t[(d+X[v]+12)%12] -= i;
|
||||
t[d] -= (c[d] - i);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int bfs() {
|
||||
int cnt[15], pos[15];
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
cnt[0] = N;
|
||||
ll k = idx(cnt);
|
||||
if (S == k) return 0;
|
||||
C[k] = 0;
|
||||
head = rear = 0;
|
||||
for (int i = 0; i < M; i++) {
|
||||
int x = (-X[i] + 12) % 12;
|
||||
cnt[x] += L[i];
|
||||
cnt[0] -= L[i];
|
||||
ll tmp = idx(cnt);
|
||||
if (!C.count(tmp)) {
|
||||
if (tmp == S) return 1;
|
||||
Q[rear++] = State(tmp, i, 1);
|
||||
C[tmp] = 1;
|
||||
}
|
||||
cnt[x] -= L[i];
|
||||
cnt[0] += L[i];
|
||||
}
|
||||
while (head < rear) {
|
||||
cur = Q[head++];
|
||||
reidx(cur.s, cnt);
|
||||
for (int i = M-1; i >= cur.f; i--) {
|
||||
memset(pos, 0, sizeof(pos));
|
||||
if (dfs1(0, cnt, pos, L[i], N, i))
|
||||
return ans;
|
||||
}
|
||||
}
|
||||
head = rear = 0;
|
||||
Q[rear++] = State(S, 0, 0);
|
||||
while (head < rear) {
|
||||
cur = Q[head++];
|
||||
reidx(cur.s, cnt);
|
||||
for (int i = M-1; i >= cur.f; i--) {
|
||||
memset(pos, 0, sizeof(pos));
|
||||
if (dfs2(0, cnt, pos, L[i], N, i)) return ans;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
while (cas--) {
|
||||
init();
|
||||
printf("%d\n", bfs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define MAX 20007
|
||||
using namespace std;
|
||||
int fa[MAX],num[MAX],t,n,m,q,pp[MAX];
|
||||
struct Query
|
||||
{
|
||||
int x,id;
|
||||
bool operator < ( const Query& a )const
|
||||
{
|
||||
return x < a.x;
|
||||
}
|
||||
}a[MAX];
|
||||
struct Edge
|
||||
{
|
||||
int u,v,w;
|
||||
bool operator < ( const Edge& a ) const
|
||||
{
|
||||
return w < a.w;
|
||||
}
|
||||
}e[MAX*5];
|
||||
void init ( )
|
||||
{
|
||||
for ( int i = 1 ; i <= n ; i++ )
|
||||
{
|
||||
num[i] = 1;
|
||||
fa[i] = i;
|
||||
}
|
||||
}
|
||||
int _find ( int x )
|
||||
{
|
||||
return fa[x] == x? x : fa[x] = _find ( fa[x] );
|
||||
}
|
||||
void _union ( int x , int y )
|
||||
{
|
||||
x = _find ( x );
|
||||
y = _find ( y );
|
||||
if ( y < x ) swap ( x , y );
|
||||
fa[y] = x;
|
||||
num[x] += num[y];
|
||||
}
|
||||
int main ( )
|
||||
{
|
||||
scanf ( "%d" ,&t );
|
||||
while ( t-- )
|
||||
{
|
||||
int ans = 0;
|
||||
scanf ( "%d%d%d" , &n , &m , &q );
|
||||
init ( );
|
||||
for ( int i = 0 ; i < m ; i++ )
|
||||
scanf ( "%d%d%d" , &e[i].u , &e[i].v , &e[i].w );
|
||||
sort ( e , e+m );
|
||||
int j = 0;
|
||||
for ( int i = 0 ; i < q ; i++ )
|
||||
{
|
||||
a[i].id = i;
|
||||
scanf ( "%d" , &a[i].x );
|
||||
}
|
||||
sort ( a , a+q );
|
||||
for ( int i = 0 ; i < q ; i++ )
|
||||
{
|
||||
while ( j < m && e[j].w <= a[i].x )
|
||||
{
|
||||
int u = _find ( e[j].u );
|
||||
int v = _find ( e[j].v );
|
||||
j++;
|
||||
if ( u == v ) continue;
|
||||
ans += (num[u]+num[v])*(num[u]+num[v]-1)-num[u]*(num[u]-1) - num[v]*(num[v]-1);
|
||||
_union ( u , v );
|
||||
}
|
||||
pp[a[i].id] = ans;
|
||||
}
|
||||
for ( int i = 0 ; i < q ; i++ )
|
||||
printf ( "%d\n" , pp[i] );
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
#define maxn 200007
|
||||
int wwa[maxn],wwb[maxn],wwv[maxn],wws[maxn];
|
||||
int cmp(int *r,int a,int b,int l){
|
||||
return r[a]==r[b]&&r[a+l]==r[b+l];
|
||||
}
|
||||
void da(int *r,int *sufix,int n,int m){
|
||||
int i,j,p,*x=wwa,*y=wwb,*t;
|
||||
for(i=0;i<m;i++)wws[i]=0;
|
||||
for(i=0;i<n;i++)wws[x[i]=r[i]]++;
|
||||
for(i=1;i<m;i++)wws[i]+=wws[i-1];
|
||||
for(i=n-1;i>=0;i--)sufix[--wws[x[i]]]=i;
|
||||
for(j=1,p=1;p<n;j*=2,m=p){
|
||||
for(p=0,i=n-j;i<n;i++)y[p++]=i;
|
||||
for(i=0;i<n;i++)
|
||||
if(sufix[i]>=j)
|
||||
y[p++]=sufix[i]-j;
|
||||
for(i=0;i<n;i++)wwv[i]=x[y[i]];
|
||||
for(i=0;i<m;i++)wws[i]=0;
|
||||
for(i=0;i<n;i++)wws[wwv[i]]++;
|
||||
for(i=1;i<m;i++)wws[i]+=wws[i-1];
|
||||
for(i=n-1;i>=0;i--)
|
||||
sufix[--wws[wwv[i]]]=y[i];
|
||||
for(t=x,x=y,y=t,p=1,x[sufix[0]]=0,i=1;i<n;i++)
|
||||
x[sufix[i]]=cmp(y,sufix[i-1],sufix[i],j)?p-1:p++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
int r[maxn];
|
||||
int rank1[maxn],height[maxn],sufix[maxn];
|
||||
void calheight(int *r,int *sufix,int n){
|
||||
int i,j,k=0;
|
||||
for(i=0;i<=n;i++) rank1[sufix[i]]=i;
|
||||
for(i=0;i<n;height[rank1[i++]]=k)
|
||||
for(k?k--:0,j=sufix[rank1[i]-1];r[i+k]==r[j+k];k++);
|
||||
return;
|
||||
}
|
||||
struct Node{
|
||||
int p,c;
|
||||
};
|
||||
int comp(Node a,Node b){
|
||||
if(a.p == b.p) return a.c < b.c;
|
||||
return a.p < b.p;
|
||||
}
|
||||
Node ans[maxn];
|
||||
char word[maxn];
|
||||
int main(){
|
||||
int t,n;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
scanf("%s",word);
|
||||
for(int i = 0;i < n; i++){
|
||||
r[i]=r[i+n] = word[i];
|
||||
}
|
||||
int len =n*4+1;
|
||||
r[n*2] = '#';
|
||||
for(int i = 0;i < n; i++){
|
||||
r[i+n*2+1] = r[i+n*3+1] = word[n-i-1];
|
||||
}
|
||||
r[len] = 0;
|
||||
da(r,sufix,len+1,328);
|
||||
calheight(r,sufix,len);
|
||||
int cnt = 0;
|
||||
ans[cnt++].p = sufix[len];
|
||||
for(int i = len-1;i > 1; i--){
|
||||
if(height[i+1] < n) break;
|
||||
if(sufix[i]>=n&&sufix[i]<=n*2) continue;
|
||||
if(sufix[i]>=n*3+1)continue;
|
||||
ans[cnt++].p = sufix[i];
|
||||
}
|
||||
for(int i = 0;i < cnt; i++){
|
||||
if(ans[i].p > 2*n){
|
||||
ans[i].c =1;
|
||||
ans[i].p = n-(ans[i].p-2*n-1);
|
||||
}
|
||||
else {
|
||||
ans[i].p++;
|
||||
ans[i].c = 0;
|
||||
}
|
||||
}
|
||||
sort(ans,ans+cnt,comp);
|
||||
printf("%d %d\n",ans[0].p,ans[0].c);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define pr(x) cout << #x << " = " << x << " "
|
||||
#define prln(x) cout << #x << " = " << x << endl
|
||||
const int N = 1e3 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
|
||||
int n, q, dp[2][N][20];
|
||||
int RMQ(int l, int r) {
|
||||
int k = 31 - __builtin_clz(r - l + 1);
|
||||
int Max = max(dp[1][l][k], dp[1][r - (1 << k) + 1][k]);
|
||||
return Max;
|
||||
}
|
||||
int main() {
|
||||
int t; scanf("%d", &t);
|
||||
while(t--) {
|
||||
scanf("%d", &n);
|
||||
for(int i = 1; i <= n; ++i) {
|
||||
scanf("%d", &dp[0][i][0]);
|
||||
dp[1][i][0] = dp[0][i][0];
|
||||
}
|
||||
for(int j = 1; (1 << j) <= n; ++j) {
|
||||
for(int i = 1; i + (1 << j) - 1 <= n; ++i) {
|
||||
dp[0][i][j] = min(dp[0][i][j - 1],
|
||||
dp[0][i + (1 << j - 1)][j - 1]);
|
||||
dp[1][i][j] = max(dp[1][i][j - 1],
|
||||
dp[1][i + (1 << j - 1)][j - 1]);
|
||||
}
|
||||
}
|
||||
scanf("%d", &q);
|
||||
while(q--) {
|
||||
int x, y; scanf("%d%d", &x, &y);
|
||||
printf("%d\n", RMQ(x, y));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 1100;
|
||||
struct tree{
|
||||
int v, l, r, f;
|
||||
tree(){}
|
||||
tree(int v, int l, int r, int f):v(v), l(l), r(r), f(f){}
|
||||
} t[maxn<<2];
|
||||
int T, n;
|
||||
int pt, sz;
|
||||
int st[maxn];
|
||||
int a[maxn];
|
||||
int ps[maxn];
|
||||
bool v[maxn];
|
||||
void work(int x){
|
||||
int pos = 0, ed = ps[x];
|
||||
while(1){
|
||||
if (pt > ed) break;
|
||||
v[a[pt]] = true;
|
||||
if (t[pos].v > a[pt]){
|
||||
if (t[pos].r == -1){
|
||||
st[a[pt]] = sz;
|
||||
t[sz] = tree(a[pt++], -1, -1, pos);
|
||||
t[pos].r = sz;
|
||||
pos = sz++;
|
||||
}
|
||||
else pos = t[pos].r;
|
||||
}
|
||||
else{
|
||||
if (t[pos].l == -1){
|
||||
st[a[pt]] = sz;
|
||||
t[sz] = tree(a[pt++], -1, -1, pos);
|
||||
t[pos].l = sz;
|
||||
pos = sz++;
|
||||
}
|
||||
else pos = t[pos].l;
|
||||
}
|
||||
}
|
||||
}
|
||||
char s[1100];
|
||||
void output(int x){
|
||||
int len = 0, px;
|
||||
while(1){
|
||||
px = x;
|
||||
x = t[x].f;
|
||||
if (x == -1) break;
|
||||
if (t[x].l == px) s[len++] = 'W';
|
||||
else s[len++] = 'E';
|
||||
}
|
||||
for (int i = 0, j = len-1; i < j; i++, j--)
|
||||
swap(s[i], s[j]);
|
||||
s[len] = 0;
|
||||
printf("%s\n", s);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &T);
|
||||
while(T--){
|
||||
scanf("%d", &n);
|
||||
for (int i = 0; i < n; i++){
|
||||
v[i+1] = false;
|
||||
scanf("%d", &a[i]);
|
||||
ps[a[i]] = i;
|
||||
}
|
||||
sz = 0, pt = 1;
|
||||
t[sz++] = tree(a[0], -1, -1, -1);
|
||||
v[a[0]] = true;
|
||||
for (int i = 1; i <= n; i++)
|
||||
if (!v[i]){ work(i); }
|
||||
int q, qq;
|
||||
scanf("%d", &q);
|
||||
for (int i = 0; i < q; i++){
|
||||
scanf("%d", &qq);
|
||||
output(st[qq]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <bitset>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
typedef unsigned long long ull;
|
||||
#define ff(i, n) for(int i=0,END=(n);i<END;i++)
|
||||
#define fff(i, n, m) for(int i=(n),END=(m);i<=END;i++)
|
||||
#define dff(i, n, m) for(int i=(n),END=(m);i>=END;i--)
|
||||
#define travel(e, u) for(int e=first[u], v=vv[first[u]]; ~e; e=nxt[e])
|
||||
#define mid ((l+r)/2)
|
||||
#define bit(n) (1ll<<(n))
|
||||
#define clr(a, b) memset(a, b, sizeof(a))
|
||||
#define debug(x) cout << #x << " = " << x << endl;
|
||||
#define ls (rt << 1)
|
||||
#define rs (ls | 1)
|
||||
#define lson l, m, ls
|
||||
#define rson m + 1, r, rs
|
||||
void work();
|
||||
int main() {
|
||||
work();
|
||||
return 0;
|
||||
}
|
||||
const int maxn = 222;
|
||||
const int maxv = 5e4 + 5 + maxn;
|
||||
const int inf = 0x3f3f3f3f;
|
||||
int n, m, p;
|
||||
int dp[maxv];
|
||||
void zero_one_pack(int v, int c, int V) {
|
||||
dff(i, V, v) {
|
||||
dp[i] = min(dp[i], dp[i - v] + c);
|
||||
}
|
||||
}
|
||||
void zero_one_pack2(int v, int c, int V) {
|
||||
dff(i, V, v) {
|
||||
dp[i] = max(dp[i], dp[i - v] + c);
|
||||
}
|
||||
}
|
||||
void multi_pack(int v, int c, int num, int V, bool flag = true) {
|
||||
int k = 1;
|
||||
while (num) {
|
||||
if (flag)
|
||||
zero_one_pack(v * k, c * k, V);
|
||||
else
|
||||
zero_one_pack2(v * k, c * k, V);
|
||||
num -= k;
|
||||
k += k;
|
||||
if (k > num) k = num;
|
||||
}
|
||||
}
|
||||
void input() {
|
||||
scanf("%d%d%d", &n, &m, &p);
|
||||
clr(dp, inf); dp[0] = 0;
|
||||
ff (i, n) {
|
||||
int v, c, num;
|
||||
scanf("%d%d%d", &v, &c, &num);
|
||||
multi_pack(v, c, num, p + 100);
|
||||
}
|
||||
int V = *min_element(dp + p, dp + p + 100);
|
||||
clr(dp, 0);
|
||||
ff (i, m) {
|
||||
int v, c, num;
|
||||
scanf("%d%d%d", &v, &c, &num);
|
||||
multi_pack(c, v, num, 50000, false);
|
||||
}
|
||||
int ans = inf;
|
||||
dff(i, 50000, 0) if (dp[i] >= V) {
|
||||
ans = min(ans, i);
|
||||
}
|
||||
if (ans == inf) {
|
||||
puts("TAT");
|
||||
} else {
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
void work() {
|
||||
int T; scanf("%d", &T);
|
||||
fff(cas, 1, T) {
|
||||
input();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cassert>
|
||||
using namespace std;
|
||||
#define debug 0
|
||||
const int maxn = 101000;
|
||||
typedef long long ll;
|
||||
ll A[maxn], inv[maxn];
|
||||
int res[20];
|
||||
int p[20];
|
||||
void gcd(ll a, ll b, ll d, ll& x, ll& y){
|
||||
if (!b) { d = a; x = 1; y = 0; }
|
||||
else{ gcd(b, a%b, d, y, x); y -= x*(a/b); }
|
||||
}
|
||||
int cal(long long n, long long m, int p){
|
||||
A[0] = A[1] = 1;
|
||||
inv[0] = inv[1] = 1;
|
||||
for (int i = 2; i <= p; i++){
|
||||
inv[i] = (long long)(p - p/i) * inv[p % i] % p;
|
||||
A[i] = A[i-1] * i % p;
|
||||
}
|
||||
for (int i = 2; i < p; i++){
|
||||
inv[i] = inv[i] * inv[i-1] % p;
|
||||
}
|
||||
if (debug){
|
||||
for (int i = 0; i < p; i++){
|
||||
assert(inv[i] * A[i] % p == 1);
|
||||
printf("%lld %lld\n", inv[i], A[i]);
|
||||
}
|
||||
}
|
||||
int ret = 1;
|
||||
while(n&&m){
|
||||
int a = n % p, b = m % p;
|
||||
if (a < b) return 0;
|
||||
n /= p, m /= p;
|
||||
ret = (long long)ret * A[a] % p * inv[b] % p * inv[a-b] % p;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
ll mul(ll a, ll b, ll p){
|
||||
ll ret = 0;
|
||||
for (; a; a>>=1){
|
||||
if (a&1){
|
||||
ret += b;
|
||||
if (ret >= p) ret -= p;
|
||||
}
|
||||
b <<= 1;
|
||||
if (b >= p) b -= p;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
ll crt(int n, int* a, int *m){
|
||||
ll M = 1, d, y, x = 0;
|
||||
for (int i = 0; i < n; i++) M *= m[i];
|
||||
for (int i = 0; i < n; i++){
|
||||
ll w = M / m[i];
|
||||
gcd(m[i], w, d, d, y);
|
||||
int sign;
|
||||
if (y < 0) sign = -1;
|
||||
else sign = 1;
|
||||
x = (x + mul(y*sign, w*a[i]%M, M) * sign) % M;
|
||||
}
|
||||
return (x + M) % M;
|
||||
}
|
||||
int T;
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &T);
|
||||
while(T--){
|
||||
ll n, m; int k;
|
||||
scanf("%I64d %I64d %d", &n, &m, &k);
|
||||
for (int i = 0; i < k; i++){
|
||||
scanf("%d", &p[i]);
|
||||
res[i] = cal(n, m, p[i]);
|
||||
}
|
||||
long long ans = crt(k, res, p);
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <cstdio>
|
||||
typedef long long LL;
|
||||
const int maxn = 100010, mod = 1000000007, inv2 = 500000004;
|
||||
int t, n, pw1[maxn], pw2[maxn], x, y, pre1x, pre1y, pre2x, pre2y, ans;
|
||||
int mod_add(int x, int y)
|
||||
{
|
||||
x += y;
|
||||
if(x >= mod)
|
||||
x -= mod;
|
||||
return x;
|
||||
}
|
||||
int mod_sub(int x, int y)
|
||||
{
|
||||
x -= y;
|
||||
if(x < 0)
|
||||
x += mod;
|
||||
return x;
|
||||
}
|
||||
int det(int x1, int y1, int x2, int y2)
|
||||
{
|
||||
return mod_sub((LL)x1 * y2 % mod, (LL)x2 * y1 % mod);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &t);
|
||||
pw1[0] = 1;
|
||||
for(int i = 1; i < maxn; ++i)
|
||||
pw1[i] = (LL)pw1[i - 1] * 2 % mod;
|
||||
pw2[0] = 1;
|
||||
for(int i = 1; i < maxn; ++i)
|
||||
pw2[i] = (LL)pw2[i - 1] * inv2 % mod;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d", &n);
|
||||
pre1x = pre1y = pre2x = pre2y = ans = 0;
|
||||
for(int i = 1; i <= n; ++i)
|
||||
{
|
||||
scanf("%d%d", &x, &y);
|
||||
ans = mod_add(ans, (LL)pw1[i - 1] * det(x, y, pre2x, pre2y) % mod);
|
||||
ans = mod_add(ans, (LL)(i == n ? inv2 : pw1[n - i - 1]) * det(pre1x, pre1y, x, y) % mod);
|
||||
pre1x = mod_add(pre1x, (LL)x * pw1[i] % mod);
|
||||
pre1y = mod_add(pre1y, (LL)y * pw1[i] % mod);
|
||||
pre2x = mod_add(pre2x, (LL)x * pw2[i] % mod);
|
||||
pre2y = mod_add(pre2y, (LL)y * pw2[i] % mod);
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn = 50005;
|
||||
int N, E, first[maxn], jump[maxn<<1], linker[maxn<<1];
|
||||
ll sz[maxn], up[maxn], dn[maxn], f[20][maxn], dep[maxn];
|
||||
void addEdge(int u, int v) {
|
||||
jump[E] = first[u];
|
||||
linker[E] = v;
|
||||
first[u] = E++;
|
||||
}
|
||||
void dfs (int u, int far, int d) {
|
||||
sz[u] = 1;
|
||||
dep[u] = d;
|
||||
f[0][u] = far;
|
||||
for (int i = first[u]; i + 1; i = jump[i]) {
|
||||
int v = linker[i];
|
||||
if (v == far) continue;
|
||||
dfs(v, u, d + 1);
|
||||
sz[u] += sz[v];
|
||||
}
|
||||
}
|
||||
void dfs (int u) {
|
||||
if (f[0][u] != -1) {
|
||||
up[u] = up[f[0][u]] + 2 * sz[u] - 1;
|
||||
dn[u] = dn[f[0][u]] + 2 * (N-sz[u]) - 1;
|
||||
} else
|
||||
up[u] = dn[u] = 0;
|
||||
for (int i = first[u]; i + 1; i = jump[i]) {
|
||||
int v = linker[i];
|
||||
if (v == f[0][u]) continue;
|
||||
dfs(v);
|
||||
}
|
||||
}
|
||||
int lca(int u, int v) {
|
||||
if (dep[u] < dep[v]) swap(u, v);
|
||||
int d = dep[u] - dep[v];
|
||||
for (int i = 0; i < 20; i++) if ((1<<i)&d)
|
||||
u = f[i][u];
|
||||
if (u == v) return u;
|
||||
for (int i = 19; i >= 0; i--) {
|
||||
if (f[i][u] != f[i][v]) {
|
||||
u = f[i][u];
|
||||
v = f[i][v];
|
||||
}
|
||||
}
|
||||
return f[0][u];
|
||||
}
|
||||
void init () {
|
||||
E = 0;
|
||||
memset(first, -1, sizeof(first));
|
||||
int u, v;
|
||||
scanf("%d", &N);
|
||||
for (int i = 1; i < N; i++) {
|
||||
scanf("%d%d", &u, &v);
|
||||
addEdge(u, v);
|
||||
addEdge(v, u);
|
||||
}
|
||||
dfs(0, -1, 0);
|
||||
dfs(0);
|
||||
for (int k = 1; k < 20; k++) {
|
||||
for (int i = 0; i < N; i++)
|
||||
f[k][i] = f[k-1][f[k-1][i]];
|
||||
}
|
||||
}
|
||||
ll get (int u, int v) {
|
||||
int l = lca(u, v);
|
||||
return up[u] - up[l] + dn[v] - dn[l];
|
||||
}
|
||||
void solve () {
|
||||
int q, p, u, v;
|
||||
scanf("%d", &q);
|
||||
while (q--) {
|
||||
ll ans = 0;
|
||||
scanf("%d%d", &p, &u);
|
||||
while (p--) {
|
||||
scanf("%d", &v);
|
||||
ans += get(u, v);
|
||||
u = v;
|
||||
}
|
||||
printf("%lld.0000\n", ans);
|
||||
}
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
while (cas--) {
|
||||
init();
|
||||
solve();
|
||||
if (cas) printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 105;
|
||||
const int maxm = 15;
|
||||
const int maxs = 200000;
|
||||
const int mod = 10007;
|
||||
int N, P, dp[maxn][maxs];
|
||||
bool exist[maxn];
|
||||
int encode (int* c, int n) {
|
||||
int ret = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
ret = ret * 3 + c[i];
|
||||
return ret;
|
||||
}
|
||||
void decode(int* c, int n, int s) {
|
||||
for (int i = n-1; i >= 0; i--) {
|
||||
c[i] = s % 3;
|
||||
s /= 3;
|
||||
}
|
||||
}
|
||||
void move(int* c, int n) {
|
||||
for (int i = n; i > 0; i--)
|
||||
c[i] = c[i-1];
|
||||
c[0] = 0;
|
||||
}
|
||||
void init () {
|
||||
scanf("%d%d", &N, &P);
|
||||
memset(exist, false, sizeof(exist));
|
||||
int k, x;
|
||||
scanf("%d", &k);
|
||||
for (int i = 0; i < k; i++) {
|
||||
scanf("%d", &x);
|
||||
exist[x] = true;
|
||||
}
|
||||
}
|
||||
void add(int& u, int v) { u = (u + v) % mod; }
|
||||
int solve () {
|
||||
int n = P + 2, cur[maxm], nxt[maxm], idx[3];
|
||||
idx[0] = 1, idx[1] = P, idx[2] = P + 2;
|
||||
memset(dp, 0, sizeof(dp));
|
||||
for (int i = 0; i < n; i++) cur[i] = 2;
|
||||
int e = encode(cur, n);
|
||||
dp[0][e] = 1;
|
||||
for (int i = 0; i < N; i++) {
|
||||
for (int s = 0; s <= e; s++) {
|
||||
if (dp[i][s] == 0) continue;
|
||||
decode(cur, n, s);
|
||||
memcpy(nxt, cur, sizeof(cur));
|
||||
move(nxt, n);
|
||||
if (exist[i+1]) {
|
||||
nxt[0] = 2;
|
||||
if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
|
||||
continue;
|
||||
}
|
||||
if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
|
||||
nxt[0] = 1;
|
||||
for (int j = 0; j < 3; j++) {
|
||||
int& v = nxt[idx[j]];
|
||||
if (v < 2) {
|
||||
v++;
|
||||
if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
|
||||
v--;
|
||||
}
|
||||
}
|
||||
nxt[0] = 2;
|
||||
for (int j = 0; j < 3; j++) {
|
||||
for (int k = j+1; k < 3; k++) {
|
||||
int& u = nxt[idx[j]];
|
||||
int& v = nxt[idx[k]];
|
||||
if (u < 2 && v < 2) {
|
||||
u++, v++;
|
||||
if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
|
||||
u--, v--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[N][e];
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
for (int kcas = 1; kcas <= cas; kcas++) {
|
||||
init();
|
||||
printf("Case #%d: %d\n", kcas, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define LL long long
|
||||
#define FOR(i,x,y) for(int i = x;i < y;i ++)
|
||||
#define IFOR(i,x,y) for(int i = x;i > y;i --)
|
||||
#define N 2
|
||||
int MOD;
|
||||
LL p;
|
||||
struct Matrix{
|
||||
LL mat[N][N];
|
||||
Matrix operator *(const Matrix& a) const{
|
||||
Matrix c;
|
||||
memset(c.mat,0,sizeof(c.mat));
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
for(int k=0;k<N;k++){
|
||||
LL ssss = ((mat[i][k]*a.mat[k][j])%MOD+MOD)%MOD;
|
||||
c.mat[i][j] = ((c.mat[i][j]+ssss)%MOD+MOD)%MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
Matrix operator ^(LL n) const{
|
||||
Matrix c;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
c.mat[i][j]=(i==j);
|
||||
}
|
||||
}
|
||||
Matrix a = *this;
|
||||
while(n)
|
||||
{
|
||||
if(n%2) c=c*a;
|
||||
a=a*a;
|
||||
n=n>>1;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
};
|
||||
Matrix ss;
|
||||
LL quickpow(LL a,LL n,int m){
|
||||
LL ret = 1;
|
||||
while(n){
|
||||
if(n&1) ret = (ret*a)%m;
|
||||
a = (a*a)%m;
|
||||
n >>= 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
int T,tCase = 0;
|
||||
scanf("%d",&T);
|
||||
ss.mat[0][0] = 10; ss.mat[0][1] = -1; ss.mat[1][0] = 1; ss.mat[1][1] = 0;
|
||||
while(T--){
|
||||
printf("Case #%d: ",++tCase);
|
||||
LL x;
|
||||
scanf("%I64d%d",&x,&MOD);
|
||||
p = (MOD-1)*(MOD+1);
|
||||
LL r = quickpow(2,x,p);
|
||||
Matrix st;
|
||||
st.mat[0][0] = 10; st.mat[0][1] = -1; st.mat[1][0] = 1; st.mat[1][1] = 0;
|
||||
st = st^r;
|
||||
LL aaaa = (((st.mat[0][0]*10)%MOD+MOD)%MOD + ((st.mat[0][1]*2)%MOD+MOD)%MOD)%MOD;
|
||||
if(!aaaa){
|
||||
printf("%d\n",MOD-1);
|
||||
}
|
||||
else
|
||||
printf("%I64d\n",aaaa-1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define INF 0x3f3f3f3f
|
||||
const int maxn = 80010;
|
||||
const int maxm = 26;
|
||||
int dp[2*maxn][maxm];
|
||||
bool vis[maxn];
|
||||
struct edge
|
||||
{
|
||||
int from, to;
|
||||
int next;
|
||||
} e[2*maxn];
|
||||
int tot,head[maxn];
|
||||
int cnt;
|
||||
int num[maxn];
|
||||
void init()
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(vis,false,sizeof(vis));
|
||||
memset(num,0,sizeof(num));
|
||||
cnt = 0;
|
||||
}
|
||||
void addedge(int u, int v)
|
||||
{
|
||||
e[cnt].from = u;
|
||||
e[cnt].to = v;
|
||||
e[cnt].next = head[u];
|
||||
head[u] = cnt++;
|
||||
}
|
||||
int ver[2*maxn], R[2*maxn], first[maxn];
|
||||
void dfs(int u ,int dep)
|
||||
{
|
||||
vis[u] = true;
|
||||
ver[++tot] = u;
|
||||
first[u] = tot;
|
||||
R[tot] = dep;
|
||||
for(int k=head[u]; k!=-1; k=e[k].next)
|
||||
if( !vis[e[k].to] )
|
||||
{
|
||||
int v = e[k].to;
|
||||
dfs(v, dep+1);
|
||||
ver[++tot] = u;
|
||||
R[tot] = dep;
|
||||
}
|
||||
}
|
||||
void ST(int n)
|
||||
{
|
||||
for(int i=1; i<=n; i++)
|
||||
dp[i][0] = i;
|
||||
for(int j=1; (1<<j)<=n; j++)
|
||||
{
|
||||
for(int i=1; i+(1<<j)-1<=n; i++)
|
||||
{
|
||||
int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
|
||||
dp[i][j] = R[a]<R[b]?a:b;
|
||||
}
|
||||
}
|
||||
}
|
||||
int RMQ(int l,int r)
|
||||
{
|
||||
int k=0;
|
||||
while((1<<(k+1))<=r-l+1)
|
||||
k++;
|
||||
int a = dp[l][k], b = dp[r-(1<<k)+1][k];
|
||||
return R[a]<R[b]?a:b;
|
||||
}
|
||||
int LCA(int u ,int v)
|
||||
{
|
||||
int x = first[u] , y = first[v];
|
||||
if(x > y) swap(x,y);
|
||||
int res = RMQ(x,y);
|
||||
return ver[res];
|
||||
}
|
||||
int DFS(int u,int fa)
|
||||
{
|
||||
for(int i = head[u]; ~i; i = e[i].next)
|
||||
{
|
||||
int v = e[i].to;
|
||||
if(v == fa)
|
||||
continue;
|
||||
DFS(v, u);
|
||||
num[u]+=num[v];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
int cas = 0;
|
||||
int n, m;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
init();
|
||||
scanf("%d%d",&n,&m);
|
||||
int u, v;
|
||||
for(int i = 0; i < n-1; i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
addedge(u, v);
|
||||
addedge(v, u);
|
||||
}
|
||||
for(int i = n; i <= m; i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
int tt = LCA(u, v);
|
||||
num[u]++;
|
||||
num[v]++;
|
||||
num[tt]-=2;
|
||||
}
|
||||
DFS(1, 1);
|
||||
int ans = INF;
|
||||
for(int i = 2; i <= n; i++)
|
||||
{
|
||||
ans = min(ans, num[i]+1);
|
||||
}
|
||||
printf("Case #%d: %d\n",++cas,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
typedef __int64 LL;
|
||||
const int maxn = 300005;
|
||||
struct tree
|
||||
{
|
||||
LL suml[maxn << 2], sumr[maxn << 2], sum[maxn << 2];
|
||||
LL add[maxn << 2];
|
||||
inline void pushup(int id, int L, int R)
|
||||
{
|
||||
LL mid = L + R >> 1;
|
||||
sum[id] = sum[id << 1] + sum[id << 1 | 1];
|
||||
suml[id] = suml[id << 1] + (mid - L + 1)*sum[id << 1 | 1] + suml[id << 1 | 1];
|
||||
sumr[id] = sumr[id << 1 | 1] + sumr[id << 1] + (R - mid)*sum[id << 1];
|
||||
}
|
||||
inline void pushdown(int id, int L, int R)
|
||||
{
|
||||
int mid = L + R >> 1;
|
||||
if (add[id])
|
||||
{
|
||||
LL ln = mid - L + 1;
|
||||
LL rn = R - mid;
|
||||
add[id << 1] += add[id];
|
||||
add[id << 1 | 1] += add[id];
|
||||
sum[id << 1] += add[id] * ln;
|
||||
sum[id << 1 | 1] += add[id] * rn;
|
||||
suml[id << 1] += add[id] * (1 + ln)*ln >> 1;
|
||||
suml[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1;
|
||||
sumr[id << 1] += add[id] * (1 + ln)*ln >> 1;
|
||||
sumr[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1;
|
||||
add[id] = 0;
|
||||
}
|
||||
}
|
||||
void build()
|
||||
{
|
||||
memset(sum, 0, sizeof(sum));
|
||||
memset(suml, 0, sizeof(suml));
|
||||
memset(sumr, 0, sizeof(sumr));
|
||||
memset(add, 0, sizeof(add));
|
||||
}
|
||||
LL queL(int id, int L, int R, int l, int r)
|
||||
{
|
||||
if (l <= L&&R <= r) return (L - l)*sum[id] + suml[id];
|
||||
else
|
||||
{
|
||||
pushdown(id, L, R);
|
||||
int mid = L + R >> 1;
|
||||
LL res = 0;
|
||||
if (l <= mid) res += queL(id << 1, L, mid, l, r);
|
||||
if (mid<r) res += queL(id << 1 | 1, mid + 1, R, l, r);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
LL queR(int id, int L, int R, int l, int r)
|
||||
{
|
||||
if (l <= L&&R <= r) return (r - R)*sum[id] + sumr[id];
|
||||
else
|
||||
{
|
||||
pushdown(id, L, R);
|
||||
int mid = L + R >> 1;
|
||||
LL res = 0;
|
||||
if (l <= mid) res += queR(id << 1, L, mid, l, r);
|
||||
if (mid<r) res += queR(id << 1 | 1, mid + 1, R, l, r);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
LL que(int id, int L, int R, int l, int r)
|
||||
{
|
||||
if (l <= L&&R <= r) return sum[id];
|
||||
else
|
||||
{
|
||||
pushdown(id, L, R);
|
||||
int mid = L + R >> 1;
|
||||
LL res = 0;
|
||||
if (l <= mid) res += que(id << 1, L, mid, l, r);
|
||||
if (mid<r) res += que(id << 1 | 1, mid + 1, R, l, r);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
void op(int id, int L, int R, int l, int r)
|
||||
{
|
||||
if (l <= L&&R <= r)
|
||||
{
|
||||
LL sn = R - L + 1;
|
||||
add[id]++;
|
||||
sum[id] += sn;
|
||||
suml[id] += (1 + sn)*sn >> 1;
|
||||
sumr[id] += (1 + sn)*sn >> 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
pushdown(id, L, R);
|
||||
int mid = L + R >> 1;
|
||||
if (l <= mid) op(id << 1, L, mid, l, r);
|
||||
if (mid<r) op(id << 1 | 1, mid + 1, R, l, r);
|
||||
pushup(id, L, R);
|
||||
}
|
||||
}
|
||||
}tz, tf;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
int ks = 0;
|
||||
while (T--)
|
||||
{
|
||||
printf("Case #%d:\n", ++ks);
|
||||
tz.build();
|
||||
tf.build();
|
||||
int n, m;
|
||||
scanf("%d %d", &n, &m);
|
||||
while (m--)
|
||||
{
|
||||
int op;
|
||||
scanf("%d", &op);
|
||||
if (op == 1)
|
||||
{
|
||||
int l, r;
|
||||
scanf("%d %d", &l, &r);
|
||||
tf.op(1, 1, n << 1, l, r);
|
||||
}
|
||||
else if (op == 2)
|
||||
{
|
||||
int l, r;
|
||||
scanf("%d %d", &l, &r);
|
||||
l += n;
|
||||
r += n;
|
||||
tz.op(1, 1, n << 1, l, r);
|
||||
}
|
||||
else
|
||||
{
|
||||
int x1, y1, x2, y2;
|
||||
scanf("%d %d %d %d", &x1, &x2, &y1, &y2);
|
||||
LL ans = 0;
|
||||
int A, B, C, D;
|
||||
A = x1 - y1 + n;
|
||||
B = x1 - y2 + n;
|
||||
C = x2 - y2 + n;
|
||||
D = x2 - y1 + n;
|
||||
if (D >= max(A, C) + 1) ans += tz.queR(1, 1, n << 1, max(A, C) + 1, D);
|
||||
if (B <= min(A, C) - 1) ans += tz.queL(1, 1, n << 1, B, min(A, C) - 1);
|
||||
ans += tz.que(1, 1, n << 1, min(A, C), max(A, C))*(min(y2 - y1, x2 - x1) + 1);
|
||||
A = x1 + y1;
|
||||
B = x1 + y2;
|
||||
C = x2 + y2;
|
||||
D = x2 + y1;
|
||||
if (A <= min(B, D) - 1) ans += tf.queL(1, 1, n << 1, A, min(B, D) - 1);
|
||||
if (C >= max(B, D) + 1) ans += tf.queR(1, 1, n << 1, max(B, D) + 1, C);
|
||||
ans += tf.que(1, 1, n << 1, min(B, D), max(B, D))*(min(y2 - y1, x2 - x1) + 1);
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#define LL long long
|
||||
#define MAXN 100010
|
||||
using namespace std;
|
||||
string s1;
|
||||
int len,k,fg,cnt,ans,fg2;
|
||||
int main(){
|
||||
int T,cas,i;
|
||||
scanf("%d",&T);
|
||||
getchar();
|
||||
for(cas=1;cas<=T;cas++)
|
||||
{
|
||||
char s2[MAXN];
|
||||
getline(cin,s1);
|
||||
len=s1.length();
|
||||
fg=0;
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(s1[i]=='c')
|
||||
{
|
||||
fg=1;
|
||||
k=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(fg)
|
||||
{
|
||||
cnt=0;
|
||||
for(i=k;i<len;i++)
|
||||
{
|
||||
s2[cnt++]=s1[i];
|
||||
}
|
||||
for(i=0;i<k;i++)
|
||||
{
|
||||
s2[cnt++]=s1[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ans=(len+1)/2;
|
||||
printf("Case #%d: %d\n",cas,ans);
|
||||
continue;
|
||||
}
|
||||
ans=1;
|
||||
fg2=1;
|
||||
int shuf=0;
|
||||
for(i=1;i<len;i++)
|
||||
{
|
||||
if(s2[i]=='f')
|
||||
{
|
||||
shuf++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(s2[i]=='c')
|
||||
{
|
||||
if(shuf<2)
|
||||
{
|
||||
printf("Case #%d: -1\n",cas);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans++;
|
||||
shuf=0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Case #%d: -1\n",cas);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(i==len&&shuf<2)
|
||||
{
|
||||
printf("Case #%d: -1\n",cas);
|
||||
continue;
|
||||
}
|
||||
if(i==len)
|
||||
{
|
||||
printf("Case #%d: %d\n",cas,ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <list>
|
||||
#include <cstdlib>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <cmath>
|
||||
#include <bitset>
|
||||
#include <cassert>
|
||||
#define ALL(a) a.begin(), a.end()
|
||||
#define clr(a, x) memset(a, x, sizeof a)
|
||||
#define X first
|
||||
#define Y second
|
||||
#define pb push_back
|
||||
#define lowbit(x) (x&(-x))
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
#define rep1(i,x,y) for(int i=x;i<=y;i++)
|
||||
#define rep(i,n) for(int i=0;i<(int)n;i++)
|
||||
using namespace std;
|
||||
const double eps = 1e-6;
|
||||
typedef long long LL;
|
||||
typedef long long ll;
|
||||
typedef pair<int, int> pii;
|
||||
const int oo =0x3f3f3f3f;
|
||||
const int N = 510;
|
||||
const int cnt[]= {6,2,5,5,4,5,6,3,7,6};
|
||||
ll d[N][2][8];
|
||||
int M,n;
|
||||
bool vis[N][2][8];
|
||||
ll dp(int i,int j,int s)
|
||||
{
|
||||
if(vis[i][j][s]) return d[i][j][s];
|
||||
vis[i][j][s] = 1;
|
||||
d[i][j][s] = 0;
|
||||
if(i == 0)
|
||||
{
|
||||
return d[i][j][s] = (j==0 && s==7);
|
||||
}
|
||||
rep(p,10) rep(q,10)
|
||||
{
|
||||
int nj = (p-j >= q ? 0 : 1);
|
||||
int a = p, b = q , c = nj*10+p-j-q;
|
||||
if((s&1) && c!=0) continue;
|
||||
if((s&2) && b!=0) continue;
|
||||
int nee = cnt[a]+((s&2) ? 0:cnt[b])+((s&1) ? 0 : cnt[c]);
|
||||
if(nee > i) continue;
|
||||
int vv[8]= {0};
|
||||
rep(t,8)
|
||||
{
|
||||
int ts = 0;
|
||||
if((t&1) && (c>0)) ts|=1;
|
||||
if((t&2) && (b>0)) ts|=2;
|
||||
if((t&4) && (a>0) && nj==0 && i==nee) ts|=4;
|
||||
if(!vv[ts]) d[i][j][s] = (d[i][j][s]+dp(i-nee,nj,s|ts))%M,vv[ts]=1;
|
||||
}
|
||||
}
|
||||
return d[i][j][s];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,kase=1;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d %d",&n,&M);
|
||||
memset(vis,false,sizeof(vis));
|
||||
printf("Case #%d: %I64d\n",kase++,dp(n-3,0,0));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,340 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include <climits>
|
||||
#include <complex>
|
||||
#include <fstream>
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <ctime>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <cmath>
|
||||
#include <functional>
|
||||
#include <numeric>
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
#define eps 1e-9
|
||||
#define PI acos(-1.0)
|
||||
#define INF 0x3f3f3f3f
|
||||
#define LLINF 1LL<<60
|
||||
#define speed std::ios::sync_with_stdio(false);
|
||||
typedef long long ll;
|
||||
typedef unsigned long long ull;
|
||||
typedef long double ld;
|
||||
typedef pair<ll, ll> pll;
|
||||
typedef complex<ld> point;
|
||||
typedef pair<int, int> pii;
|
||||
typedef pair<pii, int> piii;
|
||||
typedef vector<int> vi;
|
||||
#define CLR(x,y) memset(x,y,sizeof(x))
|
||||
#define CPY(x,y) memcpy(x,y,sizeof(x))
|
||||
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
|
||||
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
|
||||
#define debug(a) cout << #a" = " << (a) << endl;
|
||||
#define debugarry(a, n) for (int i = 0; i < (n); i++) { cout << #a"[" << i << "] = " << (a)[i] << endl; }
|
||||
#define mp(x,y) make_pair(x,y)
|
||||
#define pb(x) push_back(x)
|
||||
#define lowbit(x) (x&(-x))
|
||||
#define MID(x,y) (x+((y-x)>>1))
|
||||
#define ls (idx<<1)
|
||||
#define rs (idx<<1|1)
|
||||
#define lson ls,l,mid
|
||||
#define rson rs,mid+1,r
|
||||
template<class T>
|
||||
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 <class T>
|
||||
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);
|
||||
}
|
||||
const int MAXN=10240;
|
||||
const int MAXM=40000;
|
||||
struct ISAP
|
||||
{
|
||||
struct nedge
|
||||
{
|
||||
int u,v,next;
|
||||
ll c;
|
||||
} e[MAXM*2];
|
||||
int head[MAXN],tot,n;
|
||||
int ss,tt;
|
||||
void Resize(int n)
|
||||
{
|
||||
this->n=n;
|
||||
}
|
||||
void Clearall()
|
||||
{
|
||||
tot=1;
|
||||
CLR(head,0);
|
||||
}
|
||||
void addedge(int u,int v,ll w)
|
||||
{
|
||||
e[++tot].v=v;
|
||||
e[tot].u=u;
|
||||
e[tot].c=w;
|
||||
e[tot].next=head[u];
|
||||
head[u]=tot;
|
||||
e[++tot].v=u;
|
||||
e[tot].u=v;
|
||||
e[tot].c=0;
|
||||
e[tot].next=head[v];
|
||||
head[v]=tot;
|
||||
}
|
||||
int dep[MAXN],gap[MAXN];
|
||||
void bfs()
|
||||
{
|
||||
CLR(dep,-1);
|
||||
CLR(gap,0);
|
||||
queue<int> que;
|
||||
gap[0]=1;
|
||||
dep[tt]=0;
|
||||
que.push(tt);
|
||||
while(!que.empty())
|
||||
{
|
||||
int u=que.front();
|
||||
que.pop();
|
||||
for(int i=head[u]; i; i=e[i].next)
|
||||
if(dep[e[i].v]==-1)
|
||||
{
|
||||
que.push(e[i].v);
|
||||
dep[e[i].v]=dep[u]+1;
|
||||
++gap[dep[e[i].v]];
|
||||
}
|
||||
}
|
||||
}
|
||||
int res,cur[MAXN],num[MAXN];
|
||||
int top;
|
||||
int MaxFlow(int s,int t)
|
||||
{
|
||||
this->ss=s;
|
||||
this->tt=t;
|
||||
bfs();
|
||||
top=res=0;
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u=ss,i;
|
||||
while(dep[ss]<n)
|
||||
{
|
||||
if(u==tt)
|
||||
{
|
||||
int temp=INF;
|
||||
int inser;
|
||||
for(i=0; i<top; i++)
|
||||
if(temp>e[num[i]].c)
|
||||
{
|
||||
temp=e[num[i]].c;
|
||||
inser=i;
|
||||
}
|
||||
for(i=0; i<top; i++)
|
||||
{
|
||||
e[num[i]].c-=temp;
|
||||
e[num[i]^1].c+=temp;
|
||||
}
|
||||
res+=temp;
|
||||
top=inser;
|
||||
u=e[num[top]].u;
|
||||
}
|
||||
if(u!=tt && gap[dep[u]-1]==0)
|
||||
break;
|
||||
for(i=cur[u]; i; i=e[i].next)
|
||||
if(e[i].c != 0 && dep[u]==dep[e[i].v]+1)
|
||||
break;
|
||||
if(i)
|
||||
{
|
||||
cur[u]=i;
|
||||
num[top++]=i;
|
||||
u=e[i].v;
|
||||
}
|
||||
else
|
||||
{
|
||||
int mi=n;
|
||||
for(i=head[u]; i; i=e[i].next)
|
||||
if(e[i].c>0 && mi>dep[e[i].v])
|
||||
{
|
||||
mi=dep[e[i].v];
|
||||
cur[u]=i;
|
||||
}
|
||||
--gap[dep[u]];
|
||||
dep[u]=mi+1;
|
||||
++gap[dep[u]];
|
||||
if(u!=ss)
|
||||
u=e[num[--top]].u;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void print()
|
||||
{
|
||||
puts("GRAPH:");
|
||||
for(int i=0; i<=n; i++)
|
||||
{
|
||||
if(!head[i])
|
||||
continue;
|
||||
printf("%d ->",i);
|
||||
for(int j=head[i]; j; j=e[j].next)
|
||||
printf("%d(%I64d) ",e[j].v,e[j].c);
|
||||
putchar('\n');
|
||||
}
|
||||
}
|
||||
}g;
|
||||
static int tim;
|
||||
struct Node
|
||||
{
|
||||
Node *ln[2];
|
||||
int cost[2],idx;
|
||||
bool f;
|
||||
void init()
|
||||
{
|
||||
f=0;
|
||||
idx=tim++;
|
||||
memset(ln,0,sizeof ln);
|
||||
memset(cost,INF,sizeof cost);
|
||||
}
|
||||
};
|
||||
struct Trie
|
||||
{
|
||||
Node T[MAXN];
|
||||
int cnt,pos[MAXN];
|
||||
Node *rt;
|
||||
Node* get()
|
||||
{
|
||||
T[cnt].init();
|
||||
return &T[cnt++];
|
||||
}
|
||||
void init()
|
||||
{
|
||||
cnt=0;
|
||||
rt=get();
|
||||
}
|
||||
void insert(int *s,int j)
|
||||
{
|
||||
Node *p=rt;
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
int v=s[i];
|
||||
if(p->ln[v]==NULL) p->ln[v]=get();
|
||||
p=p->ln[v];
|
||||
}
|
||||
p->f=1;
|
||||
pos[j]=p->idx;
|
||||
}
|
||||
void find(char *s,int cost)
|
||||
{
|
||||
Node *p=rt;
|
||||
for(int i=0; s[i]; i++)
|
||||
{
|
||||
int v=s[i]-'0';
|
||||
if(p->ln[v]==NULL) return;
|
||||
if(s[i+1]==0) p->cost[v]=min(p->cost[v],cost);
|
||||
else p=p->ln[v];
|
||||
}
|
||||
}
|
||||
} pre,su;
|
||||
int n,m,ss,tt;
|
||||
int a[9];
|
||||
char str[9],x[9];
|
||||
void dfs(Node *p,int flag)
|
||||
{
|
||||
if(flag)
|
||||
{
|
||||
if(p->ln[0])
|
||||
{
|
||||
g.addedge(p->ln[0]->idx,p->idx,p->cost[0]);
|
||||
dfs(p->ln[0],1);
|
||||
}
|
||||
if(p->ln[1])
|
||||
{
|
||||
g.addedge(p->ln[1]->idx,p->idx,p->cost[1]);
|
||||
dfs(p->ln[1],1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(p->ln[0])
|
||||
{
|
||||
g.addedge(p->idx,p->ln[0]->idx,p->cost[0]);
|
||||
dfs(p->ln[0],0);
|
||||
}
|
||||
if(p->ln[1])
|
||||
{
|
||||
g.addedge(p->idx,p->ln[1]->idx,p->cost[1]);
|
||||
dfs(p->ln[1],0);
|
||||
}
|
||||
}
|
||||
}
|
||||
void build()
|
||||
{
|
||||
for(int i=1; i<=n; i++)
|
||||
g.addedge(pre.pos[i],su.pos[i],INF);
|
||||
dfs(pre.rt,0);
|
||||
dfs(su.rt ,1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,cas=1;
|
||||
read(T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d %d",&n,&m);
|
||||
tim=0;
|
||||
pre.init();su.init();g.Clearall();
|
||||
for(int i=1,x; i<=n; i++)
|
||||
{
|
||||
scanf("%d",&x);
|
||||
for(int j=0; j<8; j++)
|
||||
if(x&(1<<7-j)) a[j]=1;
|
||||
else a[j]=0;
|
||||
pre.insert(a,i);
|
||||
for(int j=0; j<8; j++)
|
||||
if(x&(1<<j)) a[j]=1;
|
||||
else a[j]=0;
|
||||
su.insert(a,i);
|
||||
}
|
||||
g.Resize(tim);
|
||||
ss=0;
|
||||
tt=su.rt->idx;
|
||||
for(int i=1,cost; i<=m; i++)
|
||||
{
|
||||
scanf("%s %s %d",str,x,&cost);
|
||||
if(str[0]=='P') pre.find(x,cost);
|
||||
else
|
||||
{
|
||||
int len=strlen(x);
|
||||
reverse(x,x+len);
|
||||
su.find(x,cost);
|
||||
}
|
||||
}
|
||||
build();
|
||||
ll ans=g.MaxFlow(ss,tt);
|
||||
printf("Case #%d: %lld\n",cas++,ans>=INF?-1:ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,310 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include <climits>
|
||||
#include <complex>
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <ctime>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <cmath>
|
||||
#include <functional>
|
||||
#include <numeric>
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
#define eps 1e-9
|
||||
#define PI acos(-1.0)
|
||||
#define INF 0x3f3f3f3f
|
||||
#define LLINF 1LL<<62
|
||||
#define speed std::ios::sync_with_stdio(false);
|
||||
typedef long long ll;
|
||||
typedef unsigned long long ull;
|
||||
typedef long double ld;
|
||||
typedef pair<ll, ll> pll;
|
||||
typedef complex<ld> point;
|
||||
typedef pair<int, int> pii;
|
||||
typedef pair<pii, int> piii;
|
||||
typedef vector<int> vi;
|
||||
#define CLR(x,y) memset(x,y,sizeof(x))
|
||||
#define CPY(x,y) memcpy(x,y,sizeof(x))
|
||||
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
|
||||
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
|
||||
#define mp(x,y) make_pair(x,y)
|
||||
#define pb(x) push_back(x)
|
||||
#define lowbit(x) (x&(-x))
|
||||
#define MID(x,y) (x+((y-x)>>1))
|
||||
#define getidx(l,r) (l+r | l!=r)
|
||||
#define ls getidx(l,mid)
|
||||
#define rs getidx(mid+1,r)
|
||||
#define lson l,mid
|
||||
#define rson mid+1,r
|
||||
#define root 1,n
|
||||
template<class T>
|
||||
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 <class T>
|
||||
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);
|
||||
}
|
||||
const int MAXN=30005;
|
||||
const int MAXM=100005;
|
||||
const int MAXQ=100005;
|
||||
int t,n,m,q;
|
||||
struct edge
|
||||
{
|
||||
int a,b;
|
||||
edge(){}
|
||||
edge(int aa,int bb):a(aa),b(bb){}
|
||||
bool operator < (const edge &o) const
|
||||
{
|
||||
if(a == o.a)
|
||||
{
|
||||
return b < o.b;
|
||||
}
|
||||
return a < o.a;
|
||||
}
|
||||
};
|
||||
multiset<edge> S;
|
||||
multiset<edge> V;
|
||||
struct Ans
|
||||
{
|
||||
int kind;
|
||||
int a;
|
||||
int b;
|
||||
int val;
|
||||
}ans[MAXQ];
|
||||
struct Edge
|
||||
{
|
||||
int u,v,w;
|
||||
int next;
|
||||
}e[MAXN<<1];
|
||||
int head[MAXN],tot;
|
||||
int siz[MAXN],p[MAXN],son[MAXN],dep[MAXN];
|
||||
int dfn[MAXN],top[MAXN],tim;
|
||||
int sum[MAXN<<1],la[MAXN<<1];
|
||||
int bingchafa[MAXN];
|
||||
int getfather(int x)
|
||||
{
|
||||
if(bingchafa[x] == x) return x;
|
||||
return bingchafa[x] = getfather(bingchafa[x]);
|
||||
}
|
||||
void init()
|
||||
{
|
||||
CLR(head,-1);CLR(sum,0);
|
||||
tot=tim=0;
|
||||
for(int i=1;i<=n;i++) bingchafa[i] = i;
|
||||
S.clear();
|
||||
V.clear();
|
||||
}
|
||||
void addedge(int u,int v,int w)
|
||||
{
|
||||
e[tot].u=u;e[tot].v=v;e[tot].w=w;
|
||||
e[tot].next=head[u];head[u]=tot++;
|
||||
}
|
||||
void dfs(int u,int fa=0,int depth=0)
|
||||
{
|
||||
siz[u]=1;son[u]=-1;
|
||||
p[u]=fa;dep[u]=depth;
|
||||
for(int i=head[u];~i;i=e[i].next)
|
||||
{
|
||||
int v=e[i].v;
|
||||
if(v==p[u]) continue;
|
||||
dfs(v,u,depth+1);
|
||||
siz[u]+=siz[v];
|
||||
if(son[u]==-1 || siz[v]>siz[son[u]])
|
||||
son[u]=v;
|
||||
}
|
||||
}
|
||||
void getid(int u,int fa)
|
||||
{
|
||||
dfn[u]=++tim;top[u]=fa;
|
||||
if(son[u]!=-1)
|
||||
getid(son[u],fa);
|
||||
for(int i=head[u];~i;i=e[i].next)
|
||||
{
|
||||
int v=e[i].v;
|
||||
if(v==p[u] || v==son[u]) continue;
|
||||
getid(v,v);
|
||||
}
|
||||
}
|
||||
void pushup(int l,int r)
|
||||
{
|
||||
int idx=getidx(l,r),mid=MID(l,r);
|
||||
sum[idx]=0;
|
||||
if(!la[ls])
|
||||
sum[idx]+=sum[ls];
|
||||
if(!la[rs])
|
||||
sum[idx]+=sum[rs];
|
||||
}
|
||||
void pushdown(int l,int r)
|
||||
{
|
||||
int idx=getidx(l,r),mid=MID(l,r);
|
||||
if(!la[idx]) return;
|
||||
la[ls]=la[idx];
|
||||
la[rs]=la[idx];
|
||||
}
|
||||
void build(int l,int r)
|
||||
{
|
||||
int idx=getidx(l,r);
|
||||
la[idx]=0;
|
||||
if(l==r)
|
||||
{
|
||||
sum[idx]=1;
|
||||
return;
|
||||
}
|
||||
int mid=MID(l,r);
|
||||
build(l,mid);
|
||||
build(mid+1,r);
|
||||
pushup(l,r);
|
||||
}
|
||||
void update2(int l,int r,int L,int R)
|
||||
{
|
||||
int idx=getidx(l,r);
|
||||
if(L==l && r==R)
|
||||
{
|
||||
la[idx]=1;
|
||||
sum[idx]=0;
|
||||
return;
|
||||
}
|
||||
pushdown(l,r);
|
||||
int mid=MID(l,r);
|
||||
if(R<=mid)
|
||||
update2(l,mid,L,R);
|
||||
else if(L>mid)
|
||||
update2(mid+1,r,L,R);
|
||||
else
|
||||
update2(l,mid,L,mid),update2(mid+1,r,mid+1,R);
|
||||
pushup(l,r);
|
||||
}
|
||||
int query(int l,int r,int L,int R)
|
||||
{
|
||||
int idx=getidx(l,r);
|
||||
if(la[idx]) return 0;
|
||||
if(L==l && r==R)
|
||||
{
|
||||
return sum[idx];
|
||||
}
|
||||
int mid=MID(l,r);
|
||||
if(R<=mid)
|
||||
return query(lson,L,R);
|
||||
if(L>mid)
|
||||
return query(rson,L,R);
|
||||
return query(lson,L,mid)+query(rson,mid+1,R);
|
||||
}
|
||||
void change(int u,int v)
|
||||
{
|
||||
while(top[u]!=top[v])
|
||||
{
|
||||
if(dep[top[u]]>dep[top[v]])
|
||||
swap(u,v);
|
||||
update2(1,tim,dfn[top[v]],dfn[v]);
|
||||
v=p[top[v]];
|
||||
}
|
||||
if(u==v) return;
|
||||
if(dep[u]>dep[v])
|
||||
swap(u,v);
|
||||
update2(1,tim,dfn[son[u]],dfn[v]);
|
||||
}
|
||||
int query(int u,int v)
|
||||
{
|
||||
int ans=0;
|
||||
while(top[u]!=top[v])
|
||||
{
|
||||
if(dep[top[u]]>dep[top[v]])
|
||||
swap(u,v);
|
||||
ans+=query(1,tim,dfn[top[v]],dfn[v]);
|
||||
v=p[top[v]];
|
||||
}
|
||||
if(u==v) return ans;
|
||||
if(dep[u]>dep[v])
|
||||
swap(u,v);
|
||||
ans+=query(1,tim,dfn[u]+1,dfn[v]);
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&t);
|
||||
for(int cas = 1;cas <= t;cas++)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&q);
|
||||
init();
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
edge tmp;
|
||||
scanf("%d%d",&tmp.a,&tmp.b);
|
||||
if(tmp.a > tmp.b) swap(tmp.a,tmp.b);
|
||||
S.insert(tmp);
|
||||
}
|
||||
for(int i=1;i<=q;i++)
|
||||
{
|
||||
scanf("%d%d%d",&ans[i].kind,&ans[i].a,&ans[i].b);
|
||||
if(ans[i].a > ans[i].b) swap(ans[i].a,ans[i].b);
|
||||
if(ans[i].kind == 1)
|
||||
{
|
||||
multiset<edge>::iterator Pos = S.find(edge(ans[i].a,ans[i].b));
|
||||
S.erase(Pos);
|
||||
}
|
||||
}
|
||||
for(multiset<edge>::iterator It = S.begin();It != S.end();++It)
|
||||
{
|
||||
if(getfather(It->a) != getfather(It->b))
|
||||
{
|
||||
bingchafa[getfather(It->a)] = getfather(It->b);
|
||||
V.insert(*It);
|
||||
}
|
||||
}
|
||||
for(multiset<edge>::iterator It = V.begin();It != V.end();++It)
|
||||
{
|
||||
addedge(It->a,It->b,1);
|
||||
addedge(It->b,It->a,1);
|
||||
}
|
||||
dfs(1);getid(1,1);
|
||||
build(1,tim);
|
||||
for(multiset<edge>::iterator It = S.begin();It != S.end();++It)
|
||||
if(V.find(*It) == V.end())
|
||||
{
|
||||
change(It->a,It->b);
|
||||
}
|
||||
for(int i=q;i>=1;i--)
|
||||
{
|
||||
if(ans[i].kind == 1)
|
||||
change(ans[i].a,ans[i].b);
|
||||
else if(ans[i].kind == 2)
|
||||
ans[i].val = query(ans[i].a,ans[i].b);
|
||||
}
|
||||
printf("Case #%d:\n",cas);
|
||||
for(int i=1;i<=q;i++)
|
||||
if(ans[i].kind == 2)
|
||||
printf("%d\n",ans[i].val);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
const int maxn = 201315;
|
||||
const int mod = 530600414;
|
||||
typedef long long LL;
|
||||
LL dp[maxn];
|
||||
LL dist[maxn];
|
||||
LL cnt[maxn];
|
||||
LL fibo[maxn];
|
||||
void init() {
|
||||
fibo[1] = 1, fibo[2] = 2;
|
||||
cnt[1] = 1, cnt[2] = 0;
|
||||
for (int i = 3; i < maxn; i ++) {
|
||||
fibo[i] = (fibo[i-1] % mod + fibo[i-2] % mod) % mod;
|
||||
cnt[i] = (cnt[i-1] % mod + cnt[i-2] % mod) % mod;
|
||||
}
|
||||
dist[1] = dist[2] = 0, dist[3] = 2;
|
||||
for (int i = 4; i < maxn; i ++) {
|
||||
dist[i] = (dist[i-1] % mod + dist[i-2] % mod + (fibo[i-1] % mod * cnt[i-2] % mod) % mod) % mod;
|
||||
}
|
||||
dp[4] = dp[1] = dp[2] = dp[3] = 0;
|
||||
for (int i = 5; i < maxn; i ++) {
|
||||
dp[i] = (dp[i-2] % mod + dp[i-1] % mod
|
||||
+ (cnt[i-1] % mod * dist[i-2] % mod) % mod
|
||||
+ (cnt[i-2] % mod * ((fibo[i-1] % mod * cnt[i-1] % mod) % mod - dist[i-1] % mod) % mod) % mod) % mod;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
init();
|
||||
int cas = 1, t, n;
|
||||
scanf("%d", &t);
|
||||
while (t --) {
|
||||
scanf("%d", &n);
|
||||
printf("Case #%d: ", cas ++);
|
||||
printf("%I64d\n", dp[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = (1<<8)+5;
|
||||
const int limit = 32 * 13 * 13;
|
||||
typedef long long ll;
|
||||
typedef map<int,ll>::iterator iter;
|
||||
int N, Q, X[20], multi[maxn], ct[maxn];
|
||||
map<int, ll> G[maxn];
|
||||
int bitcount(int s) { return s == 0 ? 0 : bitcount(s>>1) + (s&1); }
|
||||
void add (int u, int s, ll k) {
|
||||
if (s < 0) return;
|
||||
G[u][s] += k;
|
||||
}
|
||||
void merge(int u, int p, int q) {
|
||||
for (iter i = G[p].begin(); i != G[p].end(); i++) {
|
||||
for (iter j = G[q].begin(); j != G[q].end(); j++) {
|
||||
ll k = 1LL * i->second * j->second;
|
||||
add(u, i->first + j->first, k * 2);
|
||||
add(u, i->first * j->first, k * 2);
|
||||
add(u, i->first - j->first, k);
|
||||
add(u, j->first - i->first, k);
|
||||
if (i->first && j->first % i->first == 0)
|
||||
add(u, j->first / i->first, k);
|
||||
if (j->first && i->first % j->first == 0)
|
||||
add(u, i->first / j->first, k);
|
||||
}
|
||||
}
|
||||
}
|
||||
ll solve () {
|
||||
ll ret = 0;
|
||||
for (int i = 1; i < (1<<N); i++) {
|
||||
int cbit = bitcount(i);
|
||||
for (int u = i; u; u = (u-1)&i) {
|
||||
int v = u^i;
|
||||
if (u < v) break;
|
||||
merge(i, u, v);
|
||||
}
|
||||
if (G[i].count(Q))
|
||||
ret += G[i][Q] * cbit * cbit;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
for (int kcas = 1; kcas <= cas; kcas++) {
|
||||
scanf("%d%d", &N, &Q);
|
||||
for (int i = 0; i < (1<<N); i++) G[i].clear();
|
||||
for (int i = 0; i < N; i++) {
|
||||
scanf("%d", &X[i]);
|
||||
G[1<<i][X[i]] = 1;
|
||||
}
|
||||
printf("Case #%d: %lld\n", kcas, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<utility>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<LL,int> PLL;
|
||||
PLL x[5],y[5];
|
||||
bool cmp1(const PLL &x,const PLL &y) {return x.first>y.first;}
|
||||
bool cmp2(const PLL &x,const PLL &y) {return x.first<y.first;}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
int n,a,b;
|
||||
LL z;
|
||||
for(int k=1;k<=T;k++)
|
||||
{
|
||||
scanf("%d%d%d",&n,&a,&b);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%lld",&z);
|
||||
x[4]=make_pair(z*z,i);
|
||||
y[4]=make_pair(z,i);
|
||||
if(i<=4)
|
||||
{
|
||||
x[i]=x[4];
|
||||
y[i]=y[4];
|
||||
}else
|
||||
{
|
||||
if(a>0)
|
||||
sort(x,x+5,cmp1);
|
||||
else sort(x,x+5,cmp2);
|
||||
if(b>0)
|
||||
sort(y,y+5,cmp1);
|
||||
else sort(y,y+5,cmp2);
|
||||
}
|
||||
}
|
||||
LL ans=-1e20;
|
||||
for(int i=0;i<min(n,2);i++)
|
||||
for(int j=0;j<min(n,2);j++)
|
||||
if(x[i].second!=y[j].second)
|
||||
ans=max(ans,x[i].first*a+b*y[j].first);
|
||||
printf("Case #%d: %lld\n",k,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,204 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int maxn = 1005;
|
||||
const double eps = 1e-7;
|
||||
struct Point
|
||||
{
|
||||
double x, y;
|
||||
Point(double x = 0, double y = 0) : x(x), y(y) { }
|
||||
bool operator < (const Point &a) const {
|
||||
return a.x < x || (a.x == x && a.y < y);
|
||||
}
|
||||
};
|
||||
typedef Point Vector;
|
||||
struct Line
|
||||
{
|
||||
Point P;
|
||||
Vector v;
|
||||
double ang;
|
||||
Line() {}
|
||||
Line(Point P, Vector v) : P(P), v(v) { ang = atan2(v.y, v.x); }
|
||||
bool operator < (const Line &L) const {
|
||||
return ang < L.ang;
|
||||
}
|
||||
};
|
||||
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);
|
||||
}
|
||||
int dcmp(double x)
|
||||
{
|
||||
if(fabs(x) < eps) return 0;
|
||||
else return x < 0 ? -1 : 1;
|
||||
}
|
||||
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;
|
||||
}
|
||||
double Area2(Point A, Point B, Point C)
|
||||
{
|
||||
return Cross(B - A, C - A);
|
||||
}
|
||||
double PolyonArea(Point *p, int n)
|
||||
{
|
||||
double area = 0;
|
||||
for(int i = 1; i < n-1; i++)
|
||||
area += Cross(p[i] - p[0], p[i+1] - p[0]);
|
||||
return area / 2;
|
||||
}
|
||||
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);
|
||||
}
|
||||
bool OnLeft(Line L, Point p)
|
||||
{
|
||||
return Cross(L.v, p - L.P) > 0;
|
||||
}
|
||||
Point GetIntersection(Line a, Line b)
|
||||
{
|
||||
Vector u = a.P - b.P;
|
||||
double t = Cross(b.v, u) / Cross(a.v, b.v);
|
||||
return a.P + a.v * t;
|
||||
}
|
||||
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 && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--;
|
||||
ch[m++] = p[i];
|
||||
}
|
||||
int k = m;
|
||||
for(int i = n-2; i >= 0; i--) {
|
||||
while(m > k && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--;
|
||||
ch[m++] = p[i];
|
||||
}
|
||||
if(n > 1) m--;
|
||||
return m;
|
||||
}
|
||||
Point p[maxn];
|
||||
Line q[maxn];
|
||||
int HalfplaneInersection(Line* L, int n, Point* poly)
|
||||
{
|
||||
sort(L, L+n);
|
||||
int first, last;
|
||||
q[first = last = 0] = L[0];
|
||||
for(int i = 1; i < n; i++) {
|
||||
while(first < last && !OnLeft(L[i], p[last - 1])) last--;
|
||||
while(first < last && !OnLeft(L[i], p[first])) first++;
|
||||
q[++last] = L[i];
|
||||
if(fabs(Cross(q[last].v, q[last-1].v)) < eps) {
|
||||
last--;
|
||||
if(OnLeft(q[last], L[i].P)) q[last] = L[i];
|
||||
}
|
||||
if(first < last) p[last-1] = GetIntersection(q[last-1], q[last]);
|
||||
}
|
||||
while(first < last && !OnLeft(q[first], p[last-1])) last--;
|
||||
if(last - first <= 1) return 0;
|
||||
p[last] = GetIntersection(q[last], q[first]);
|
||||
int m = 0;
|
||||
for(int i = first; i <= last; i++) poly[m++] = p[i];
|
||||
return m;
|
||||
}
|
||||
double PolygonArea(Point *p, int n) {
|
||||
double area = 0;
|
||||
for(int i = 1; i < n-1; i++)
|
||||
area += Cross(p[i] - p[0], p[i+1] - p[0]);
|
||||
return fabs(area / 2);
|
||||
}
|
||||
Point poly[1005];
|
||||
Point g[105][2005];
|
||||
Point P2[10];
|
||||
Line line[105];
|
||||
double twox[105][2005];
|
||||
double twoy[105][2005];
|
||||
double xx[105][2005];
|
||||
double yy[105][2005];
|
||||
int n, m;
|
||||
void work()
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i = 1; i <= n; i++) {
|
||||
twox[i][0] = twoy[i][0] = xx[i][0] = yy[i][0] = 0;
|
||||
for(int j = 1; j <= m; j++) {
|
||||
scanf("%lf%lf", &g[i][j].x, &g[i][j].y);
|
||||
twox[i][j] = g[i][j].x * g[i][j].x;
|
||||
twoy[i][j] = g[i][j].y * g[i][j].y;
|
||||
twox[i][j] += twox[i][j-1];
|
||||
twoy[i][j] += twoy[i][j-1];
|
||||
xx[i][j] = g[i][j].x + xx[i][j-1];
|
||||
yy[i][j] = g[i][j].y + yy[i][j-1];
|
||||
}
|
||||
}
|
||||
for(int i = 1; i <= n; i++) {
|
||||
int cnt = 0;
|
||||
for(int j = 1; j <= n; j++) {
|
||||
if(i == j) continue;
|
||||
double a = 0, b = 0, c = 0;
|
||||
a = 2 * (xx[i][m] - xx[j][m]);
|
||||
b = 2 * (yy[i][m] - yy[j][m]);
|
||||
c += twox[j][m] + twoy[j][m];
|
||||
c -= twox[i][m] + twoy[i][m];
|
||||
Point P;
|
||||
Vector v(b, -a);
|
||||
if(fabs(a) > fabs(b)) P = Point(-c / a, 0);
|
||||
else P = Point(0, -c / b);
|
||||
line[cnt++] = Line(P, v);
|
||||
}
|
||||
for(int j = 0; j < 4; j++) {
|
||||
line[cnt++] = Line(P2[j], P2[(j+1)%4] - P2[j]);
|
||||
}
|
||||
int t = HalfplaneInersection(line, cnt, poly);
|
||||
double area = PolygonArea(poly, t);
|
||||
int ans = area + 0.5;
|
||||
printf("%d%c", ans, i == n ? '\n' : ' ');
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
P2[0] = Point(0, 0);
|
||||
P2[1] = Point(4095, 0);
|
||||
P2[2] = Point(4095, 4095);
|
||||
P2[3] = Point(0, 4095);
|
||||
int _;
|
||||
scanf("%d", &_);
|
||||
for(int i = 1; i <= _; i++) {
|
||||
printf("Case #%d: ", i);
|
||||
work();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
const int maxn=1100;
|
||||
int T;
|
||||
int n,m,r;
|
||||
int vis[maxn];
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d",&n);
|
||||
memset(vis,0,sizeof(vis));
|
||||
int ans=0;
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%d %d",&r,&m);
|
||||
vis[r]+=m;
|
||||
}
|
||||
for(int i=0;i<=500;i++){
|
||||
if(vis[i]>0){
|
||||
if(vis[i]%64==0){
|
||||
ans+=vis[i]/64;
|
||||
}
|
||||
else{
|
||||
ans+=vis[i]/64+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!ans%36)
|
||||
printf("%d\n",ans/36);
|
||||
else
|
||||
printf("%d\n",ans/36+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define ll long long
|
||||
using namespace std;
|
||||
const int N = 1005;
|
||||
const int MOD = 1e9 + 7;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
int n, p, a[N], f[N][N];
|
||||
int main() {
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while (t--) {
|
||||
scanf("%d%d", &n, &p);
|
||||
memset(f, 0, sizeof(f));
|
||||
f[0][0] = 1;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
scanf("%d", &a[i]);
|
||||
a[i] %= p;
|
||||
a[i] = (a[i] + p) % p;
|
||||
}
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 0; j < p; j++) {
|
||||
f[i][j] = (f[i][j] + f[i - 1][j]) % MOD;
|
||||
f[i][(j + a[i]) % p] = (f[i][(j + a[i]) % p] + f[i - 1][j]) % MOD;
|
||||
}
|
||||
}
|
||||
printf("%d\n", f[n][0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
#pragma comment(linker, "/STACK:1677721600")
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <climits>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#define pb push_back
|
||||
#define mp make_pair
|
||||
#define LL long long
|
||||
#define lson lo,mi,rt<<1
|
||||
#define rson mi+1,hi,rt<<1|1
|
||||
#define Min(a,b) ((a)<(b)?(a):(b))
|
||||
#define Max(a,b) ((a)>(b)?(a):(b))
|
||||
#define mem(a,b) memset(a,b,sizeof(a))
|
||||
#define rep(i,a,b) for(int i=(a); i<=(b); i++)
|
||||
#define dec(i,a,b) for(int i=(a); i>=(b); i--)
|
||||
using namespace std;
|
||||
const int mod = 1e9 + 7;
|
||||
const double eps = 1e-8;
|
||||
const double ee = exp(1.0);
|
||||
const int inf = 0x3f3f3f3f;
|
||||
const int maxn = 500 + 10;
|
||||
const double pi = acos(-1.0);
|
||||
const LL iinf = 0x3f3f3f3f3f3f3f3f;
|
||||
int readT()
|
||||
{
|
||||
char c;
|
||||
int ret = 0,flg = 0;
|
||||
while(c = getchar(), (c < '0' || c > '9') && c != '-');
|
||||
if(c == '-') flg = 1; else ret = c ^ 48;
|
||||
while( c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48);
|
||||
return flg ? - ret : ret;
|
||||
}
|
||||
int c[maxn][maxn];
|
||||
int a[maxn][maxn];
|
||||
int n, m;
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x & -x;
|
||||
}
|
||||
void update(int x, int y, int num)
|
||||
{
|
||||
for (int i = x; i <= n; i += lowbit(i))
|
||||
{
|
||||
for (int j = y; j <= m; j += lowbit(j))
|
||||
{
|
||||
c[i][j] ^= num;
|
||||
}
|
||||
}
|
||||
}
|
||||
int query(int x, int y)
|
||||
{
|
||||
int res = 0;
|
||||
int t = x;
|
||||
for (int i = x; i > 0; i -= lowbit(i))
|
||||
{
|
||||
for (int j = y; j > 0; j -= lowbit(j))
|
||||
{
|
||||
res ^= c[i][j];
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int sum(int x0, int y0, int x1, int y1)
|
||||
{
|
||||
x0--, y0--;
|
||||
return query(x1, y1) ^ query(x0, y1) ^ query(x1, y0) ^ query(x0, y0);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase = readT();
|
||||
while (ncase--)
|
||||
{
|
||||
mem(c, 0);
|
||||
n = readT();
|
||||
m = readT();
|
||||
int q = readT();
|
||||
rep(i, 1, n)
|
||||
{
|
||||
rep(j, 1, m)
|
||||
{
|
||||
a[i][j] = readT();
|
||||
update(i, j, a[i][j]);
|
||||
}
|
||||
}
|
||||
while (q--)
|
||||
{
|
||||
int op = readT();
|
||||
if (op == 1)
|
||||
{
|
||||
int x1 = readT();
|
||||
int y1 = readT();
|
||||
int x2 = readT();
|
||||
int y2 = readT();
|
||||
int ans = sum(x1, y1, x2, y2);
|
||||
puts(ans ? "Yes" : "No");
|
||||
}
|
||||
else
|
||||
{
|
||||
int x = readT();
|
||||
int y = readT();
|
||||
int num =readT();
|
||||
update(x, y, num ^ a[x][y]);
|
||||
a[x][y] = num;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,236 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
#define mp(x, y) make_pair(x, y)
|
||||
const int maxn = 300005;
|
||||
const int maxm = 300005;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int mod = 1e9+7;
|
||||
struct node *null;
|
||||
struct node
|
||||
{
|
||||
int size, rev;
|
||||
LL val, sum;
|
||||
node *fa, *ch[2];
|
||||
void init()
|
||||
{
|
||||
rev = val = sum = 0;
|
||||
fa = ch[0] = ch[1] = null;
|
||||
}
|
||||
inline bool d()
|
||||
{
|
||||
return fa->ch[1] == this;
|
||||
}
|
||||
inline bool isroot()
|
||||
{
|
||||
return fa == null || fa->ch[0] != this && fa->ch[1] != this;
|
||||
}
|
||||
inline void setc(node *p, int d)
|
||||
{
|
||||
ch[d] = p;
|
||||
p->fa = this;
|
||||
}
|
||||
inline void pushup()
|
||||
{
|
||||
sum = ch[0]->sum * ch[1]->sum % mod * ((val - 1) * val / 2) % mod;
|
||||
}
|
||||
inline void flip()
|
||||
{
|
||||
if(this == null) return;
|
||||
swap(ch[0], ch[1]);
|
||||
rev ^= 1;
|
||||
}
|
||||
inline void pushdown()
|
||||
{
|
||||
if(rev) {
|
||||
ch[0]->flip();
|
||||
ch[1]->flip();
|
||||
rev = 0;
|
||||
}
|
||||
}
|
||||
inline void go()
|
||||
{
|
||||
if(!isroot()) fa->go();
|
||||
pushdown();
|
||||
}
|
||||
void rot()
|
||||
{
|
||||
node *f = fa, *ff = fa->fa;
|
||||
int c = d(), cc = fa->d();
|
||||
f->setc(ch[!c], c);
|
||||
this->setc(f, !c);
|
||||
if(ff->ch[cc] == f) ff->setc(this, cc);
|
||||
else this->fa = ff;
|
||||
f->pushup();
|
||||
}
|
||||
node* splay()
|
||||
{
|
||||
go();
|
||||
while(!isroot()) {
|
||||
if(!fa->isroot()) d() == fa->d() ? fa->rot() : rot();
|
||||
rot();
|
||||
}
|
||||
pushup();
|
||||
return this;
|
||||
}
|
||||
node* access()
|
||||
{
|
||||
for(node *p = this, *q = null; p != null; q = p, p = p->fa) {
|
||||
p->splay()->setc(q, 1);
|
||||
p->pushup();
|
||||
}
|
||||
return splay();
|
||||
}
|
||||
inline void makeroot()
|
||||
{
|
||||
access()->flip();
|
||||
}
|
||||
node* getroot() {
|
||||
node *x;
|
||||
for(x = access(); x->pushdown(), x->ch[0] != null; x = x->ch[0]);
|
||||
return x;
|
||||
}
|
||||
void cut()
|
||||
{
|
||||
access();
|
||||
ch[0]->fa = null;
|
||||
ch[0] = null;
|
||||
pushup();
|
||||
}
|
||||
void cut(node *o)
|
||||
{
|
||||
makeroot();
|
||||
o->cut();
|
||||
}
|
||||
void link(node *p)
|
||||
{
|
||||
makeroot();
|
||||
fa = p;
|
||||
}
|
||||
}*Node[maxn], pool[maxm], *tail;
|
||||
struct ope
|
||||
{
|
||||
int kk, u, v;
|
||||
ope(int kk = 0, int u = 0, int v = 0) : kk(kk), u(u), v(v) {}
|
||||
}op[maxn];
|
||||
struct Edge
|
||||
{
|
||||
int v;
|
||||
Edge *next;
|
||||
}*H[maxn], *edges, E[maxn];
|
||||
vector<int> to[maxn];
|
||||
LL res[maxn];
|
||||
int T[maxn];
|
||||
int a[maxn];
|
||||
int n, m;
|
||||
void addedges(int u, int v)
|
||||
{
|
||||
edges->v = v;
|
||||
edges->next = H[u];
|
||||
H[u] = edges++;
|
||||
}
|
||||
node* newnode(int val)
|
||||
{
|
||||
tail->init();
|
||||
tail->val = val;
|
||||
tail->sum = tail->val * (tail->val - 1) / 2;
|
||||
return tail++;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
tail = pool;
|
||||
null = newnode(1);
|
||||
null->sum = 1;
|
||||
edges = E;
|
||||
memset(H, 0, sizeof H);
|
||||
memset(T, 0, sizeof T);
|
||||
memset(res, -1, sizeof res);
|
||||
}
|
||||
bool add(int u, int v)
|
||||
{
|
||||
if(u == v) return 0;
|
||||
if(Node[u]->getroot() == Node[v]->getroot()) return 0;
|
||||
Node[u]->link(Node[v]);
|
||||
return true;
|
||||
}
|
||||
bool del(int u, int v)
|
||||
{
|
||||
if(u == v) return 0;
|
||||
if(Node[u]->getroot() != Node[v]->getroot()) return 0;
|
||||
Node[u]->makeroot();
|
||||
Node[v]->access();
|
||||
if(Node[v]->ch[0] != Node[u] || Node[u]->ch[1] != null) return 0;
|
||||
else Node[v]->cut(Node[u]);
|
||||
return 1;
|
||||
}
|
||||
LL query(node *a, node *b)
|
||||
{
|
||||
a->access();
|
||||
for(a = null; b != null; a = b, b = b->fa) {
|
||||
b->splay();
|
||||
if(b->fa == null) return b->ch[1]->sum * a->sum % mod * (b->val * (b->val - 1) / 2) % mod;
|
||||
b->setc(a, 1);
|
||||
b->pushup();
|
||||
}
|
||||
}
|
||||
void modify(int u, LL val)
|
||||
{
|
||||
Node[u]->access();
|
||||
Node[u]->val = val;
|
||||
Node[u]->pushup();
|
||||
}
|
||||
void dfs(int ti)
|
||||
{
|
||||
LL tmp = 0;
|
||||
int flag = 0;
|
||||
if(op[ti].kk == 1) flag = add(op[ti].u, op[ti].v);
|
||||
if(op[ti].kk == 2) flag = del(op[ti].u, op[ti].v);
|
||||
if(op[ti].kk == 4) {
|
||||
if(Node[op[ti].u]->getroot() != Node[op[ti].v]->getroot()) res[ti] = 0;
|
||||
else res[ti] = query(Node[op[ti].u], Node[op[ti].v]);
|
||||
}
|
||||
if(op[ti].kk == 5) {
|
||||
tmp = a[op[ti].u];
|
||||
a[op[ti].u] = op[ti].v;
|
||||
modify(op[ti].u, op[ti].v);
|
||||
}
|
||||
for(Edge *e = H[ti]; e; e = e->next) dfs(e->v);
|
||||
if(op[ti].kk == 2 && flag) add(op[ti].u, op[ti].v);
|
||||
if(op[ti].kk == 1 && flag) del(op[ti].u, op[ti].v);
|
||||
if(op[ti].kk == 5) {
|
||||
a[op[ti].u] = tmp;
|
||||
modify(op[ti].u, tmp);
|
||||
}
|
||||
}
|
||||
void work()
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i = 1; i <= n; i++) to[i].clear();
|
||||
for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
|
||||
for(int i = 1; i <= n; i++) Node[i] = newnode(a[i]);
|
||||
for(int i = 1; i <= m; i++) {
|
||||
int kk, u, v;
|
||||
scanf("%d", &kk);
|
||||
if(kk == 3) scanf("%d", &u), T[i] = u;
|
||||
else scanf("%d%d", &u, &v), T[i] = i-1;
|
||||
op[i] = ope(kk, u, v);
|
||||
}
|
||||
for(int i = 1; i <= m; i++) addedges(T[i], i);
|
||||
dfs(0);
|
||||
for(int i = 1; i <= m; i++) if(res[i] != -1) printf("%lld\n", res[i]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int _;
|
||||
scanf("%d", &_);
|
||||
while(_--) {
|
||||
init();
|
||||
work();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,166 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<sstream>
|
||||
#include<string>
|
||||
#include<bitset>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL LINF = (1LL <<63);
|
||||
const int INF = 1 << 31;
|
||||
const int NS = 100010;
|
||||
const int MS = 19;
|
||||
const int MOD = 1000000007;
|
||||
const int EDGE_MAX = NS;
|
||||
struct graphEdge
|
||||
{
|
||||
int pst;
|
||||
int next;
|
||||
};
|
||||
struct ForwardStart
|
||||
{
|
||||
int top;
|
||||
int head[EDGE_MAX];
|
||||
graphEdge edge[EDGE_MAX << 1];
|
||||
void init(int len)
|
||||
{
|
||||
top = 0;
|
||||
memset(head, -1, sizeof(int) * len);
|
||||
}
|
||||
void addEdge(int u, int v)
|
||||
{
|
||||
edge[top].pst = v;
|
||||
edge[top].next = head[u];
|
||||
head[u] = top++;
|
||||
}
|
||||
void printAll()
|
||||
{
|
||||
printf("top = %d\n", top);
|
||||
for(int i = 1; i < EDGE_MAX; i++)
|
||||
{
|
||||
if(-1 != head[i])
|
||||
{
|
||||
printf("head[%2d]'son:%2d", i, edge[head[i]].pst);
|
||||
for(int j = edge[head[i]].next; j != -1; j = edge[j].next)
|
||||
{
|
||||
printf(",%2d", edge[j].pst);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
}
|
||||
}cTree;
|
||||
bitset<NS> isPrime;
|
||||
vector<int> fac[NS];
|
||||
int miu[NS];
|
||||
void prepare()
|
||||
{
|
||||
isPrime.set();
|
||||
isPrime[1] = false;
|
||||
miu[1] = 1;
|
||||
for(int i = 2; i < NS; i++)
|
||||
{
|
||||
if(isPrime[i])
|
||||
{
|
||||
for(int j = i; j < NS; j+=i)
|
||||
{
|
||||
isPrime[j] = false;
|
||||
int k = j / i;
|
||||
if(k % i)
|
||||
{
|
||||
miu[j] = -miu[k];
|
||||
}
|
||||
else
|
||||
{
|
||||
miu[j] = 0;
|
||||
}
|
||||
fac[j].push_back(i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(miu[i] != 0)
|
||||
{
|
||||
for(int j = i; j < NS; j+=i)
|
||||
{
|
||||
fac[j].push_back(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int n;
|
||||
int val[NS];
|
||||
int ans[NS];
|
||||
int sz[NS];
|
||||
int dp[NS];
|
||||
void dfs(int rt, int fa)
|
||||
{
|
||||
vector<int> temp;
|
||||
sz[rt] = 1;
|
||||
int value = val[rt];
|
||||
int len = fac[value].size();
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
int d = fac[value][i];
|
||||
int cnt = dp[d];
|
||||
temp.push_back(cnt);
|
||||
dp[d] += 1;
|
||||
}
|
||||
for(int i = cTree.head[rt]; i != -1; i = cTree.edge[i].next)
|
||||
{
|
||||
int cson = cTree.edge[i].pst;
|
||||
if(cson == fa) continue;
|
||||
dfs(cson, rt);
|
||||
sz[rt] += sz[cson];
|
||||
}
|
||||
ans[rt] = sz[rt];
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
int d = fac[value][i];
|
||||
int cnt = dp[d] - temp[i];
|
||||
if(cnt > 0)
|
||||
{
|
||||
ans[rt] += miu[d] * cnt;
|
||||
}
|
||||
}
|
||||
return ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
prepare();
|
||||
int nCase = 1;
|
||||
while(~scanf("%d", &n))
|
||||
{
|
||||
cTree.init(n + n + 2);
|
||||
int u, v;
|
||||
for(int i = 1; i < n; i++)
|
||||
{
|
||||
scanf("%d %d", &u, &v);
|
||||
cTree.addEdge(u, v);
|
||||
cTree.addEdge(v, u);
|
||||
}
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d", &val[i]);
|
||||
if(val[i] < 0)
|
||||
{
|
||||
val[i] = - val[i];
|
||||
}
|
||||
}
|
||||
memset(dp, 0, sizeof(dp));
|
||||
dfs(1, -1);
|
||||
printf("Case #%d:", nCase++);
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
printf(" %d", ans[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define N 10010
|
||||
vector<int>G[N];
|
||||
int n,len;
|
||||
char value[N],an[N];
|
||||
int dis[N];
|
||||
int f[N];
|
||||
bool visit[N];
|
||||
void init() {
|
||||
for(int i = 1; i <= n; i++) G[i].clear();
|
||||
memset(dis,0,sizeof(dis));
|
||||
memset(visit,0,sizeof(visit));
|
||||
}
|
||||
void dfs(int u) {
|
||||
int ma = -10000000;
|
||||
visit[u] = 1;
|
||||
for(int i = 0; i < G[u].size(); i++)
|
||||
if(!visit[G[u][i]]) {
|
||||
dfs(G[u][i]);
|
||||
f[G[u][i]] = u;
|
||||
ma = max(ma,dis[G[u][i]]);
|
||||
}
|
||||
if(ma == -10000000)
|
||||
dis[u] = 1;
|
||||
else
|
||||
dis[u] = ma+1;
|
||||
}
|
||||
bool dfs1(int u,int x,int len1) {
|
||||
visit[u] = 1;
|
||||
if(x > len) return 1;
|
||||
if(dis[u] > len1)
|
||||
for(int i = 0; i < G[u].size(); i++) {
|
||||
if(value[G[u][i]] == an[x] && !visit[G[u][i]]) {
|
||||
if(dfs1(G[u][i],x+1,len1-1)) return 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if(value[f[u]] == an[x] && !visit[f[u]]) {
|
||||
return dfs1(f[u],x+1,len1-1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main() {
|
||||
int t;scanf("%d",&t);
|
||||
int ca = 1;
|
||||
while(t--) {
|
||||
scanf("%d",&n);
|
||||
init();
|
||||
int x,y;
|
||||
for(int i = 1; i < n; i++) {
|
||||
scanf("%d%d",&x,&y);
|
||||
G[x].push_back(y);
|
||||
G[y].push_back(x);
|
||||
}
|
||||
scanf("%s",value+1);
|
||||
scanf("%s",an+1);
|
||||
dfs(1); bool flag = 0;
|
||||
len = strlen(an+1);
|
||||
for(int i = 1; i <= n; i++)
|
||||
if(value[i] == an[1]) {
|
||||
memset(visit,0,sizeof(visit));
|
||||
if(dfs1(i,2,len-1)) {
|
||||
printf("Case #%d: Find\n",ca++);
|
||||
flag = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!flag) printf("Case #%d: Impossible\n",ca++);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
const int N = 100000;
|
||||
const int C = 26;
|
||||
char s[N + 1];
|
||||
struct State {
|
||||
int length;
|
||||
int first;
|
||||
State* parent;
|
||||
State* go[C];
|
||||
State* extend(State*, int);
|
||||
};
|
||||
int state_count;
|
||||
State states[N << 1];
|
||||
State* new_state(int length) {
|
||||
State* state = states + (state_count ++);
|
||||
state->length = length;
|
||||
state->first = -1;
|
||||
state->parent = NULL;
|
||||
memset(state->go, 0, sizeof(state->go));
|
||||
return state;
|
||||
}
|
||||
State* State::extend(State* start, int token) {
|
||||
State *p = this;
|
||||
State *np = new_state(length + 1);
|
||||
while (p && !p->go[token]) {
|
||||
p->go[token] = np;
|
||||
p = p->parent;
|
||||
}
|
||||
if (!p) {
|
||||
np->parent = start;
|
||||
} else {
|
||||
State *q = p->go[token];
|
||||
if (p->length + 1 == q->length) {
|
||||
np->parent = q;
|
||||
} else {
|
||||
State *nq = new_state(p->length + 1);
|
||||
memcpy(nq->go, q->go, sizeof(q->go));
|
||||
nq->parent = q->parent;
|
||||
np->parent = q->parent = nq;
|
||||
while (p && p->go[token] == q) {
|
||||
p->go[token] = nq;
|
||||
p = p->parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
return np;
|
||||
}
|
||||
int cost[C], a, b, match[N + 1], queue[N + 1];
|
||||
State* end[N + 1];
|
||||
long long minimum[N + 1];
|
||||
int main() {
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for (int t = 1; t <= T; ++ t) {
|
||||
scanf("%s", s);
|
||||
for (int i = 0; i < C; ++ i) {
|
||||
scanf("%d", cost + i);
|
||||
}
|
||||
scanf("%d%d", &a, &b);
|
||||
int n = strlen(s);
|
||||
state_count = 0;
|
||||
end[0] = new_state(0);
|
||||
for (int i = 0; i < n; ++ i) {
|
||||
end[i + 1] = end[i]->extend(end[0], s[i]- 'a');
|
||||
}
|
||||
for (int i = 0; i < n; ++ i) {
|
||||
for (State* p = end[i + 1]; p && !~p->first; p = p->parent) {
|
||||
p->first = i;
|
||||
}
|
||||
}
|
||||
State* p = end[0];
|
||||
for (int i = 0, l = 0; i < n; ++ i) {
|
||||
int c = s[i] - 'a';
|
||||
while (!p->go[c]) {
|
||||
p = p->parent;
|
||||
l = std::min(l, p->length);
|
||||
}
|
||||
p = p->go[c];
|
||||
l ++;
|
||||
while (p->first > i - l) {
|
||||
l --;
|
||||
if (p->parent->length == l) {
|
||||
p = p->parent;
|
||||
}
|
||||
}
|
||||
match[i + 1] = l;
|
||||
}
|
||||
minimum[0] = 0;
|
||||
int head = 0;
|
||||
int tail = 0;
|
||||
queue[tail ++] = 0;
|
||||
for (int i = 1; i <= n; ++ i) {
|
||||
minimum[i] = minimum[i - 1] + cost[s[i - 1] - 'a'];
|
||||
while (head < tail && queue[head] < i - match[i]) {
|
||||
head ++;
|
||||
}
|
||||
if (head < tail) {
|
||||
int j = queue[head];
|
||||
minimum[i] = std::min(minimum[i], minimum[j] + (long long)a * (i - j) + b + b);
|
||||
}
|
||||
#define VALUE(i) (minimum[i] - (long long)a * (i))
|
||||
while (head < tail && VALUE(queue[tail - 1]) > VALUE(i)) {
|
||||
tail --;
|
||||
}
|
||||
#undef VALUE
|
||||
queue[tail ++] = i;
|
||||
}
|
||||
std::cout << "Case #" << t << ": " << minimum[n] << std::endl;;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn = 1024 + 5;
|
||||
const int mod = 1e9 + 7;
|
||||
struct Rectangle {
|
||||
int x1, y1, x2, y2, c;
|
||||
Rectangle (int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0, int c = 0): x1(x1), y1(y1), x2(x2), y2(y2), c(c) {}
|
||||
void read() { scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c); }
|
||||
int size() { return (x2-x1+1)*(y2-y1+1); }
|
||||
bool in(const Rectangle& u) const {
|
||||
return x1 <= u.x1 && u.x2 <= x2 && y1 <= u.y1 && u.y2 <= y2;
|
||||
}
|
||||
}R[15];
|
||||
int N, M, H, W, cc, all, ct[15][maxn], sz[15][maxn];
|
||||
vector<int> X, Y, C, G[15];
|
||||
int bitcount(int x) { return x == 0 ? 0 : bitcount(x>>1) + (x&1); }
|
||||
void init () {
|
||||
scanf("%d%d%d%d", &H, &W, &M, &N);
|
||||
X.clear(), Y.clear(), C.clear();
|
||||
for (int i = 0; i < N; i++) {
|
||||
R[i].read();
|
||||
X.push_back(R[i].x1-1);
|
||||
X.push_back(R[i].x2);
|
||||
Y.push_back(R[i].y1-1);
|
||||
Y.push_back(R[i].y2);
|
||||
C.push_back(R[i].c);
|
||||
}
|
||||
X.push_back(0);
|
||||
X.push_back(H);
|
||||
Y.push_back(0);
|
||||
Y.push_back(W);
|
||||
sort(X.begin(), X.end());
|
||||
sort(Y.begin(), Y.end());
|
||||
sort(C.begin(), C.end());
|
||||
int cx = unique(X.begin(), X.end()) - X.begin();
|
||||
int cy = unique(Y.begin(), Y.end()) - Y.begin();
|
||||
cc = unique(C.begin(), C.end()) - C.begin();
|
||||
int id[15], rk[15];
|
||||
for (int i = 0; i < cc; i++) G[i].clear();
|
||||
for (int i = 0; i < N; i++) {
|
||||
id[i] = lower_bound(C.begin(), C.begin()+cc, R[i].c) - C.begin();
|
||||
rk[i] = G[id[i]].size();
|
||||
G[id[i]].push_back(i);
|
||||
}
|
||||
all = 0;
|
||||
memset(ct, 0, sizeof(ct));
|
||||
memset(sz, 0, sizeof(sz));
|
||||
for (int x = 1; x < cx; x++) {
|
||||
for (int y = 1; y < cy; y++) {
|
||||
int t = cc, s = 0;
|
||||
Rectangle tmp = Rectangle(X[x-1]+1, Y[y-1]+1, X[x], Y[y]);
|
||||
for (int i = 0; i < N; i++) {
|
||||
if (R[i].in(tmp)) {
|
||||
if (id[i] < t)
|
||||
s = 0, t = id[i];
|
||||
if (t == id[i])
|
||||
s |= (1<<rk[i]);
|
||||
}
|
||||
}
|
||||
if (t == cc) all += tmp.size();
|
||||
else {
|
||||
int add = tmp.size();
|
||||
for (int j = s; j; j = (j-1)&s)
|
||||
ct[t][j] += add;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int c = 0; c < cc; c++) {
|
||||
int s = (1<<G[c].size());
|
||||
for (int i = 0; i < s; i++) {
|
||||
for (int j = i; j; j = (j-1)&i)
|
||||
sz[c][i] += ct[c][j] * (bitcount(j)&1 ? 1 : -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
ll pow_mod(ll x, ll n) {
|
||||
ll ret = 1;
|
||||
while (n) {
|
||||
if (n&1) ret = ret * x % mod;
|
||||
x = x * x % mod;
|
||||
n >>= 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int solve () {
|
||||
ll ret = pow_mod(M, all);
|
||||
for (int i = 0; i < cc; i++) {
|
||||
int t = 0, n = (1<<G[i].size());
|
||||
for (int s = 0; s < n; s++) {
|
||||
int si = bitcount(s)&1 ? -1 : 1;
|
||||
t = ((t + si * pow_mod(C[i]-1, sz[i][s]) * pow_mod(C[i], sz[i][n-1]-sz[i][s])) % mod + mod) % mod;
|
||||
}
|
||||
ret = ret * t % mod;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
for (int kcas = 1; kcas <= cas; kcas++) {
|
||||
init();
|
||||
printf("Case #%d: %d\n", kcas, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
struct Point {
|
||||
ll x, y;
|
||||
Point(ll x = 0, ll y = 0): x(x), y(y) {}
|
||||
void read() { scanf("%lld%lld", &x, &y); }
|
||||
bool operator < (const Point& u) const { return x < u.x || (x == u.x && y < u.y); }
|
||||
bool operator == (const Point& u) const { return !(*this < u) && !(u < *this); }
|
||||
bool operator != (const Point& u) const { return !(*this == u); }
|
||||
bool operator > (const Point& u) const { return u < *this; }
|
||||
bool operator <= (const Point& u) const { return *this < u || *this == u; }
|
||||
bool operator >= (const Point& u) const { return *this > u || *this == u; }
|
||||
Point operator + (const Point& u) { return Point(x + u.x, y + u.y); }
|
||||
Point operator - (const Point& u) { return Point(x - u.x, y - u.y); }
|
||||
Point operator * (const double u) { return Point(x * u, y * u); }
|
||||
Point operator / (const double u) { return Point(x / u, y / u); }
|
||||
ll operator ^ (const Point& u) { return x*u.y - y*u.x; }
|
||||
};
|
||||
typedef Point Vector;
|
||||
ll Cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }
|
||||
ll getArea (Point* p, int n) {
|
||||
ll ret = 0;
|
||||
for (int i = 0; i < n-1; i ++)
|
||||
ret += Cross(p[i]-p[0], p[i+1]-p[0]);
|
||||
return ret < 0 ? -ret : ret;
|
||||
}
|
||||
int getConvexHull (Point* p, int n, Point* ch) {
|
||||
sort(p, p + n);
|
||||
int m = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
while (m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--;
|
||||
ch[m++] = p[i];
|
||||
}
|
||||
int k = m;
|
||||
for (int i = n-2; i >= 0; i--) {
|
||||
while (m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--;
|
||||
ch[m++] = p[i];
|
||||
}
|
||||
if (n > 1) m--;
|
||||
return m;
|
||||
}
|
||||
const int maxn = 105;
|
||||
int N, K;
|
||||
ll dp[maxn][maxn];
|
||||
Point P[maxn], Q[maxn];
|
||||
ll solve () {
|
||||
ll allarea = getArea(P, N);
|
||||
if (K >= N) return allarea;
|
||||
ll ret = 0;
|
||||
bool vis[maxn];
|
||||
memset(vis, 0, sizeof(vis));
|
||||
int ti = min(5 * (N / K), N);
|
||||
for (int t = 0; t < ti; t++) {
|
||||
int s = rand() % N;
|
||||
while (vis[s]) s = rand() % N;
|
||||
vis[s] = 1;
|
||||
memset(dp, 0, sizeof(dp));
|
||||
dp[0][0] = allarea;
|
||||
for (int i = 1; i <= N; i++) {
|
||||
int u = (i + s) % N;
|
||||
ll sum = 0;
|
||||
for (int j = i-1; j >= 0; j--) {
|
||||
int v = (j + s) % N;
|
||||
int p = (v + 1) % N;
|
||||
ll tmp = ((P[p]-P[u])^(P[v]-P[u]));
|
||||
if (tmp < 0) tmp = -tmp;
|
||||
sum += tmp;
|
||||
for (int x = K; x > 0; x--)
|
||||
dp[i][x] = max(dp[i][x], dp[j][x-1]-sum);
|
||||
}
|
||||
}
|
||||
ret = max(ret, dp[N][K]);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main () {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
srand((int)time(NULL));
|
||||
for (int kcas = 1; kcas <= cas; kcas++) {
|
||||
scanf("%d%d", &N, &K);
|
||||
for (int i = 0; i < N; i++) Q[i].read();
|
||||
N = getConvexHull(Q, N, P);
|
||||
printf("Case #%d: %lld\n", kcas, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
const int maxn=155555;
|
||||
ll sum[maxn*4+4];
|
||||
int add;
|
||||
int a[maxn];
|
||||
int L,R;
|
||||
int MOD;
|
||||
int p;
|
||||
void pushup(int rt){
|
||||
sum[rt]=sum[rt<<1]*sum[rt<<1|1]%MOD;
|
||||
}
|
||||
void build(int l,int r,int rt){
|
||||
if(l==r){
|
||||
sum[rt]=1;
|
||||
return ;
|
||||
}
|
||||
int m=(l+r)>>1;
|
||||
build(lson);
|
||||
build(rson);
|
||||
pushup(rt);
|
||||
}
|
||||
void update(int l,int r,int rt){
|
||||
if(l==r){
|
||||
sum[rt]=add;
|
||||
return ;
|
||||
}
|
||||
int m=(l+r)>>1;
|
||||
if(p<=m)
|
||||
update(lson);
|
||||
else
|
||||
update(rson);
|
||||
pushup(rt);
|
||||
}
|
||||
ll query(int l,int r,int rt){
|
||||
ll ret=1;
|
||||
if(L<=l&&R>=r)
|
||||
return sum[rt];
|
||||
int m=(l+r)>>1;
|
||||
if(L<=m)
|
||||
ret*=query(lson)%MOD;
|
||||
if(R>m)
|
||||
ret*=query(rson)%MOD;
|
||||
return ret%MOD;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int op,u,q;
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
for(int case1=1;case1<=t;case1++){
|
||||
printf("Case #%d:\n",case1);
|
||||
scanf("%d%d",&q,&MOD);
|
||||
build(1,q,1);
|
||||
for(int i=1;i<=q;i++){
|
||||
scanf("%d%d",&op,&u);
|
||||
if(op==1){
|
||||
p=i;
|
||||
add=u;
|
||||
update(1,q,1);
|
||||
L=1;
|
||||
R=i;
|
||||
printf("%I64d\n",query(1,q,1)%MOD);
|
||||
}
|
||||
else{
|
||||
p=u;
|
||||
add=1;
|
||||
update(1,q,1);
|
||||
L=1;
|
||||
R=i;
|
||||
printf("%I64d\n",query(1,q,1)%MOD);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<cstdlib>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<vector>
|
||||
#include<cmath>
|
||||
#include<map>
|
||||
#define pi (2*acos(0))
|
||||
#define maxn 1000000
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
for (int k=1;k<=t;k++)
|
||||
{
|
||||
double ax, ay, bx, by, cx, cy;
|
||||
scanf("%lf%lf%lf%lf%lf%lf", &ax, &ay, &bx, &by, &cx, &cy);
|
||||
double t1 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
|
||||
double ab = sqrt(t1);
|
||||
double t2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy);
|
||||
double bc = sqrt(t2);
|
||||
double h = sqrt(t1 - t2/4);
|
||||
double angle = acos(bc/(2.0*ab));
|
||||
double d = bc / sin(angle);
|
||||
double ans = 0;
|
||||
ans = d * angle;
|
||||
ans = ans + h;
|
||||
printf("Case #%d: %.4f\n", k, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <map>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#include <vector>
|
||||
#include <cstdio>
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define INF 0x3f3f3f3f
|
||||
#define inf -0x3f3f3f3f
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
#define mem0(a) memset(a,0,sizeof(a))
|
||||
#define mem1(a) memset(a,-1,sizeof(a))
|
||||
#define mem(a, b) memset(a, b, sizeof(a))
|
||||
typedef long long ll;
|
||||
char s[1010];
|
||||
int l[1010],r[1010];
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%s",s);
|
||||
mem0(l);
|
||||
mem0(r);
|
||||
int len=strlen(s);
|
||||
for(int i=len-1;i>=0;i--){
|
||||
if(i==len-1)
|
||||
r[i]=(s[i]==')');
|
||||
else
|
||||
r[i]=r[i+1]+(s[i]==')');
|
||||
}
|
||||
for(int i=0;i<len;i++){
|
||||
if(i==0)
|
||||
l[i]=(s[i]=='(');
|
||||
else
|
||||
l[i]=l[i-1]+(s[i]=='(');
|
||||
}
|
||||
int ans=INF;
|
||||
for(int i=0;i<len;i++)
|
||||
ans=min(ans,l[i]+r[i]-1);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define N 110000
|
||||
#define pr pair<int,int>
|
||||
#define lson l,mid,no<<1
|
||||
#define rson mid+1,r,no<<1|1
|
||||
#define mod 1000000007ll
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
int dis[N<<1],len;
|
||||
pr L[N];
|
||||
ll sum[N<<3],cov[N<<3];
|
||||
ll P[N],S[N];
|
||||
void Pushdown(int no,int len)
|
||||
{
|
||||
if(cov[no])
|
||||
{
|
||||
cov[no<<1]+=cov[no];
|
||||
cov[no<<1|1]+=cov[no];
|
||||
sum[no<<1]+=cov[no]*(len-(len>>1));
|
||||
sum[no<<1|1]+=cov[no]*(len>>1);
|
||||
cov[no]=0;
|
||||
}
|
||||
}
|
||||
void Pushup(int no)
|
||||
{
|
||||
sum[no]=sum[no<<1]+sum[no<<1|1];
|
||||
}
|
||||
void update(int l,int r,int no,int st,int en)
|
||||
{
|
||||
if(st<=l&&r<=en)
|
||||
{
|
||||
cov[no]++;
|
||||
sum[no]+=r-l+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
int mid=l+r>>1;
|
||||
Pushdown(no,r-l+1);
|
||||
if(en<=mid) update(lson,st,en);
|
||||
else if(st>mid) update(rson,st,en);
|
||||
else update(lson,st,en),update(rson,st,en);
|
||||
Pushup(no);
|
||||
}
|
||||
}
|
||||
int query(int l,int r,int no,int k)
|
||||
{
|
||||
if(l==r)
|
||||
return sum[no];
|
||||
else
|
||||
{
|
||||
int mid=l+r>>1;
|
||||
Pushdown(no,r-l+1);
|
||||
if(k<=mid) return query(lson,k);
|
||||
else return query(rson,k);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int c,T;
|
||||
int n,i,l,r;
|
||||
scanf("%d",&T);
|
||||
P[1]=1;
|
||||
for(i=2;i<N;i++)
|
||||
P[i]=P[i-1]*2%mod;
|
||||
for(i=1;i<N;i++)
|
||||
S[i]=(S[i-1]+P[i])%mod;
|
||||
for(c=1;c<=T;c++)
|
||||
{
|
||||
memset(sum,0,sizeof(sum));
|
||||
memset(cov,0,sizeof(cov));
|
||||
scanf("%d",&n);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d",&L[i].first,&L[i].second);
|
||||
dis[i+i-1]=L[i].first;
|
||||
dis[i+i]=L[i].second;
|
||||
}
|
||||
sort(dis+1,dis+n+n+1);
|
||||
len=unique(dis+1,dis+n+n+1)-dis-1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
l=lower_bound(dis+1,dis+len+1,L[i].first)-dis;
|
||||
r=lower_bound(dis+1,dis+len+1,L[i].second)-dis;
|
||||
if(l<=r-1)
|
||||
update(1,len-1,1,l,r-1);
|
||||
}
|
||||
ll ans=0;
|
||||
for(i=1;i<len;i++)
|
||||
{
|
||||
ans=(ans+(S[n]-S[n-query(1,len-1,1,i)]+mod)%mod*(((ll)dis[i+1]-dis[i]+mod)%mod)%mod)%mod;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#define scan(x) scanf("%d",&(x))
|
||||
#define scan2(x,y) scanf("%d%d",&(x),&(y))
|
||||
#define scan3(x,y,z) scanf("%d%d%d",&(x),&(y),&(z))
|
||||
#define scan4(x,y,z,k) scanf("%d%d%d%d",&(x),&(y),&(z),&(k))
|
||||
const int maxn = 3003;
|
||||
const int maxm = maxn * maxn;
|
||||
const int inf = 1000000000;
|
||||
int n, m;
|
||||
__int64 mst;
|
||||
int map[maxn][maxn];
|
||||
int dp[maxn][maxn], best[maxn][maxn];
|
||||
int dis[maxn], pre[maxn];
|
||||
bool vis[maxn];
|
||||
vector<int> edge[maxn];
|
||||
#include<iostream>
|
||||
int minz(int a, int b)
|
||||
{
|
||||
return a < b ? a : b;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
for(j = 0; j < n; j++)
|
||||
map[i][j] = dp[i][j] = inf;
|
||||
edge[i].clear();
|
||||
vis[i] = 0;
|
||||
pre[i] = -1;
|
||||
dis[i] = inf;
|
||||
}
|
||||
}
|
||||
void input()
|
||||
{
|
||||
for(int i=0;i<n;i++){
|
||||
for(int j=i+1;j<n;j++){
|
||||
int w;scan(w);
|
||||
map[i][j] = map[j][i] = w;
|
||||
}
|
||||
}
|
||||
}
|
||||
void prim()
|
||||
{
|
||||
int i, j, k;
|
||||
for(i = 1; i < n; i++)
|
||||
{
|
||||
dis[i] = map[0][i];
|
||||
pre[i] = 0;
|
||||
}
|
||||
dis[0] = inf;
|
||||
vis[0] = 1;
|
||||
pre[0] = -1;
|
||||
mst = 0;
|
||||
for(i = 0; i < n-1; i++)
|
||||
{
|
||||
k = 0;
|
||||
for(j = 1; j < n; j++)
|
||||
if(!vis[j] && dis[k] > dis[j])
|
||||
k = j;
|
||||
vis[k] = 1;
|
||||
mst += dis[k];
|
||||
if(pre[k] != -1)
|
||||
edge[k].push_back(pre[k]),
|
||||
edge[pre[k]].push_back(k);
|
||||
for(j = 1; j < n; j++)
|
||||
if(!vis[j] && dis[j] > map[k][j] )
|
||||
dis[j] = map[k][j], pre[j] = k;
|
||||
}
|
||||
}
|
||||
int dfs1(int u, int fa, int rt)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < edge[u].size(); i++)
|
||||
{
|
||||
int v = edge[u][i];
|
||||
if(v == fa) continue;
|
||||
dp[rt][u] = minz(dp[rt][u], dfs1(v, u, rt));
|
||||
}
|
||||
if(fa != rt) dp[rt][u] = minz(dp[rt][u], map[rt][u]);
|
||||
return dp[rt][u];
|
||||
}
|
||||
int dfs2(int u, int fa, int rt)
|
||||
{
|
||||
int i;
|
||||
int ans = dp[u][rt];
|
||||
for(i = 0; i < edge[u].size(); i++)
|
||||
{
|
||||
int v = edge[u][i];
|
||||
if(v == fa) continue;
|
||||
ans = minz(ans, dfs2(v, u, rt));
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i,j;
|
||||
for(i = 0; i < n; i++)
|
||||
dfs1(i, -1, i);
|
||||
for(i = 0; i < n; i++)
|
||||
for(j = 0; j < edge[i].size(); j++)
|
||||
{
|
||||
int v = edge[i][j];
|
||||
best[i][v] = best[v][i] = dfs2(v, i, i);
|
||||
}
|
||||
}
|
||||
void query()
|
||||
{
|
||||
int ans =0 ;
|
||||
for(int i=0;i<n;i++){
|
||||
int x=i;
|
||||
for(int j=0;j<edge[i].size() ; j++){
|
||||
int y=edge[i][j];
|
||||
if(x<y) continue;
|
||||
int sum = mst - map[x][y] + best[x][y];
|
||||
if(sum != mst){
|
||||
ans++;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main(){
|
||||
int T;scan(T);
|
||||
while(T--){
|
||||
scan(n);
|
||||
m=n-1;
|
||||
init();
|
||||
input();
|
||||
prim();
|
||||
solve();
|
||||
query();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <typeinfo>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <stack>
|
||||
typedef long long ll;
|
||||
using namespace std;
|
||||
#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
|
||||
#define maxn 1000006
|
||||
#define mod 1000000007
|
||||
#define eps 1e-9
|
||||
#define e exp(1.0)
|
||||
#define PI acos(-1)
|
||||
const double EP = 1E-10 ;
|
||||
int Num;
|
||||
const ll inf=999999999;
|
||||
inline ll read()
|
||||
{
|
||||
ll x=0,f=1;char ch=getchar();
|
||||
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
|
||||
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
|
||||
return x*f;
|
||||
}
|
||||
vector<int> Q;
|
||||
map<int,int> H;
|
||||
struct node
|
||||
{
|
||||
int x,y;
|
||||
};
|
||||
node p[maxn];
|
||||
int b[maxn];
|
||||
vector<int> Q1[maxn];
|
||||
int main()
|
||||
{
|
||||
int t=read();
|
||||
for(int cas=1;cas<=t;cas++)
|
||||
{
|
||||
int n=read();
|
||||
H.clear();
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
p[i].x=read(),p[i].y=read();
|
||||
Q.push_back(p[i].x);
|
||||
Q.push_back(p[i].y);
|
||||
}
|
||||
sort(Q.begin(),Q.end());
|
||||
Q.erase(unique(Q.begin(),Q.end()),Q.end());
|
||||
int len = Q.size();
|
||||
for(int i=0;i<len;i++)
|
||||
H[Q[i]]=i;
|
||||
for(int i=0;i<len;i++)
|
||||
Q1[i].clear(),b[i]=0;
|
||||
Q.clear();
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
Q1[H[p[i].x]].push_back(H[p[i].y]);
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
sort(Q1[i].begin(),Q1[i].end());
|
||||
Q1[i].erase(unique(Q1[i].begin(),Q1[i].end()),Q1[i].end());
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
for(int j=0;j<Q1[i].size();j++)
|
||||
b[Q1[i][j]]++;
|
||||
}
|
||||
int ans1 = 0,ans2 = 0,ans3 = 0;
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
if(Q1[i].size()==0)continue;
|
||||
if(Q1[i].size()==1)
|
||||
{
|
||||
if(b[Q1[i][0]]==1)
|
||||
ans3++;
|
||||
}
|
||||
else
|
||||
{
|
||||
int flag = 1;
|
||||
for(int j=0;j<Q1[i].size();j++)
|
||||
{
|
||||
if(b[Q1[i][j]]!=1)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
ans1++;
|
||||
}
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
Q1[i].clear(),b[i]=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
Q1[H[p[i].y]].push_back(H[p[i].x]);
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
sort(Q1[i].begin(),Q1[i].end());
|
||||
Q1[i].erase(unique(Q1[i].begin(),Q1[i].end()),Q1[i].end());
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
for(int j=0;j<Q1[i].size();j++)
|
||||
b[Q1[i][j]]++;
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
if(Q1[i].size()==0)continue;
|
||||
if(Q1[i].size()==1)
|
||||
{
|
||||
if(b[Q1[i][0]]==1)
|
||||
ans3++;
|
||||
}
|
||||
else
|
||||
{
|
||||
int flag = 1;
|
||||
for(int j=0;j<Q1[i].size();j++)
|
||||
{
|
||||
if(b[Q1[i][j]]!=1)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
ans2++;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d %d %d\n",cas,ans1,ans2,ans3/2);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
#pragma warning(disable:4996)
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
#define maxn 1005
|
||||
int n1, m1, k1;
|
||||
int n2, m2, k2;
|
||||
bool tar1[maxn];
|
||||
bool tar2[maxn];
|
||||
int go1[maxn][26];
|
||||
int go2[maxn][26];
|
||||
int prestate[maxn*maxn];
|
||||
char prechar[maxn*maxn];
|
||||
bool vis[maxn*maxn];
|
||||
bool check(int x)
|
||||
{
|
||||
return tar1[x / n2] != tar2[x%n2];
|
||||
}
|
||||
int nextState(int x, int c)
|
||||
{
|
||||
return go1[x / n2][c] * n2 + go2[x%n2][c];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T; cin >> T; int ca = 0;
|
||||
while (T--)
|
||||
{
|
||||
memset(go1, -1, sizeof(go1));
|
||||
memset(go2, -1, sizeof(go2));
|
||||
memset(tar1, 0, sizeof(tar1));
|
||||
memset(tar2, 0, sizeof(tar2));
|
||||
int accept;
|
||||
int ui, vi;
|
||||
char ci[3];
|
||||
scanf("%d%d%d", &n1, &m1, &k1);
|
||||
for (int i = 0; i < k1; ++i){
|
||||
scanf("%d", &accept);
|
||||
tar1[accept] = true;
|
||||
}
|
||||
for (int i = 0; i < m1; ++i){
|
||||
scanf("%d%d%s", &ui, &vi, ci);
|
||||
go1[ui][ci[0] - 'a'] = vi;
|
||||
}
|
||||
for (int i = 0; i <= n1; ++i){
|
||||
for (int k = 0; k < 26; ++k){
|
||||
if (go1[i][k] == -1) go1[i][k] = n1;
|
||||
}
|
||||
}
|
||||
scanf("%d%d%d", &n2, &m2, &k2);
|
||||
for (int i = 0; i < k2; ++i){
|
||||
scanf("%d", &accept);
|
||||
tar2[accept] = true;
|
||||
}
|
||||
for (int i = 0; i < m2; ++i){
|
||||
scanf("%d%d%s", &ui, &vi, ci);
|
||||
go2[ui][ci[0] - 'a'] = vi;
|
||||
}
|
||||
for (int i = 0; i <= n2; ++i){
|
||||
for (int k = 0; k < 26; ++k){
|
||||
if (go2[i][k] == -1) go2[i][k] = n2;
|
||||
}
|
||||
}
|
||||
++n1; ++n2;
|
||||
int ans = -1;
|
||||
memset(vis, 0, sizeof(vis));
|
||||
queue<int> Q;
|
||||
Q.push(0);
|
||||
vis[0] = true;
|
||||
while (!Q.empty())
|
||||
{
|
||||
int state = Q.front(); Q.pop();
|
||||
if (check(state)){
|
||||
ans = state;
|
||||
break;
|
||||
}
|
||||
for (int k = 0; k < 26; ++k){
|
||||
int nstate = nextState(state, k);
|
||||
if (!vis[nstate]){
|
||||
Q.push(nstate);
|
||||
vis[nstate] = true;
|
||||
prestate[nstate] = state;
|
||||
prechar[nstate] = k;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (-1 == ans){
|
||||
printf("Case #%d: 0\n", ++ca);
|
||||
continue;
|
||||
}
|
||||
string ts;
|
||||
while (ans != 0){
|
||||
ts.push_back(char('a' + prechar[ans]));
|
||||
ans = prestate[ans];
|
||||
}
|
||||
reverse(ts.begin(), ts.end());
|
||||
printf("Case #%d: %s\n", ++ca, ts.c_str());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<map>
|
||||
using namespace std ;
|
||||
const int maxn = 1e5+10 ;
|
||||
int a[maxn] , b[maxn] ;
|
||||
int c[maxn] ;
|
||||
pair<int , int> pre[maxn] ;
|
||||
int len_b = 0 ;
|
||||
int len_a = 0 ;
|
||||
int find_b(int l , int r , int v)
|
||||
{
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l+r)>> 1 ;
|
||||
if(b[mid]>=v)
|
||||
l = mid+1 ;
|
||||
else r = mid - 1 ;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int find_a(int l , int r ,int v)
|
||||
{
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l + r) >> 1 ;
|
||||
if(a[mid]<=v)
|
||||
l = mid+1 ;
|
||||
else r = mid - 1 ;
|
||||
}
|
||||
return l ;
|
||||
}
|
||||
int find_ans_a(int l , int r , int v)
|
||||
{
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l+r)>>1 ;
|
||||
if(a[mid]<=v)
|
||||
l = mid + 1 ;
|
||||
else r = mid - 1 ;
|
||||
}
|
||||
return r ;
|
||||
}
|
||||
int find_ans_b(int l , int r , int v)
|
||||
{
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l+r) >> 1 ;
|
||||
if(b[mid] >= v)
|
||||
l = mid + 1 ;
|
||||
else r = mid - 1 ;
|
||||
}
|
||||
return r ;
|
||||
}
|
||||
void debuga()
|
||||
{
|
||||
for(int i = 1;i <= len_a;i++)
|
||||
printf("%d%c" , a[i] , i == len_ ?'\n' :' ') ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t ;
|
||||
scanf("%d" , &t) ;
|
||||
int cas = 0 ;
|
||||
while(t--)
|
||||
{
|
||||
int n , l ;
|
||||
scanf("%d%d" , &n , &l) ;
|
||||
for(int i = 1;i <= n;i++)
|
||||
a[i] = b[i] = 0 ;
|
||||
for(int i = 1;i <= n;i++)
|
||||
scanf("%d" , &c[i]) ;
|
||||
len_a = len_b = 0 ;
|
||||
for(int j = n;j > l;j--)
|
||||
{
|
||||
int pos = find_b(1 , len_ , c[j]) ;
|
||||
pre[j] = make_pair(pos , b[pos]) ;
|
||||
if(!b[pos])len_b++ ;
|
||||
b[pos] = c[j] ;
|
||||
}
|
||||
int ans = len_ ;
|
||||
for(int i = 1;i <= n-l;i++)
|
||||
{
|
||||
int pos = find_a(1 , len_ , c[i]) ;
|
||||
if(a[pos] == 0)len_a++ ;
|
||||
a[pos] = c[i] ;
|
||||
pair<int , int> tmp = pre[i+l] ;
|
||||
if(tmp.second == 0)len_b--;
|
||||
else b[tmp.first] = tmp.second ;
|
||||
int pos_1 = find_ans_b(1 , len_ , c[i]) ;
|
||||
ans = max(pos+pos_ , ans) ;
|
||||
if(tmp.second != 0)
|
||||
{
|
||||
int pos_2 = find_ans_a(1 , len_ , tmp.second) ;
|
||||
ans = max(ans , pos_2 + tmp.first) ;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: " , ++cas) ;
|
||||
printf("%d\n" , ans) ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#define LL long long
|
||||
#define MOD 1000000007
|
||||
using namespace std;
|
||||
LL b1, q, a1, d, n, m;
|
||||
LL ans, dis[10005];
|
||||
void input()
|
||||
{
|
||||
ans = 0;
|
||||
scanf("%I64d%I64d%I64d%I64d%I64d%I64d", &b1, &q, &a1, &d, &n, &m);
|
||||
}
|
||||
void exgcd(LL a, LL b, LL &x, LL &y, LL &d)
|
||||
{
|
||||
if (b == 0)
|
||||
{
|
||||
x = 1;
|
||||
y = 0;
|
||||
d = a;
|
||||
}
|
||||
else
|
||||
{
|
||||
exgcd(b, a%b, y, x, d);
|
||||
y -= a/b*x;
|
||||
}
|
||||
}
|
||||
LL modDiv(LL a, LL b)
|
||||
{
|
||||
LL x, y, d;
|
||||
exgcd(b, MOD, x, y, d);
|
||||
x = (x+MOD) % MOD;
|
||||
x = (x*a/d) % MOD;
|
||||
return x;
|
||||
}
|
||||
LL quickPow(LL x, LL n)
|
||||
{
|
||||
LL a = 1;
|
||||
while (n)
|
||||
{
|
||||
a *= n&1 ? x : 1;
|
||||
a %= MOD;
|
||||
n >>= 1 ;
|
||||
x *= x;
|
||||
x %= MOD;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
void work()
|
||||
{
|
||||
LL now = b1, tmp;
|
||||
now %= MOD;
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
tmp = modDiv(now, q-1);
|
||||
now = now+tmp;
|
||||
now %= MOD;
|
||||
dis[i] = (a1+(i-1)*d%MOD-tmp)%MOD;
|
||||
dis[i] = (dis[i]+MOD)%MOD;
|
||||
}
|
||||
LL qt = 1;
|
||||
ans += qt*dis[n];
|
||||
for (int i = n-1; i > 0; --i)
|
||||
{
|
||||
qt = modDiv((qt*((n+m-1)-i)%MOD+MOD)%MOD, n-i);
|
||||
ans += (qt*dis[i])%MOD;
|
||||
ans %= MOD;
|
||||
}
|
||||
tmp = quickPow(q, (m-1)%(MOD-1))%MOD;
|
||||
ans += now*tmp%MOD;
|
||||
ans %= MOD;
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for (int times = 1; times <= T; ++times)
|
||||
{
|
||||
printf("Case #%d: ", times);
|
||||
input();
|
||||
work();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <typeinfo>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <stack>
|
||||
typedef long long ll;
|
||||
using namespace std;
|
||||
#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
|
||||
#define maxn 300006
|
||||
#define mod 1000000007
|
||||
#define eps 1e-9
|
||||
#define e exp(1.0)
|
||||
#define PI acos(-1)
|
||||
const double EP = 1E-10 ;
|
||||
int Num;
|
||||
const ll inf=999999999;
|
||||
inline ll read()
|
||||
{
|
||||
ll x=0,f=1;char ch=getchar();
|
||||
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
|
||||
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
|
||||
return x*f;
|
||||
}
|
||||
int get(ll x)
|
||||
{
|
||||
int c =0 ;
|
||||
while (x >0)
|
||||
{
|
||||
if((x &1) ==1)
|
||||
c++; ;
|
||||
x >>=1 ;
|
||||
}
|
||||
return c ;
|
||||
}
|
||||
ll change(ll x,int num)
|
||||
{
|
||||
for(int i=0;i<132;i++)
|
||||
{
|
||||
if((x&(1LL<<i))==0)
|
||||
{
|
||||
x|=(1LL<<i);
|
||||
num--;
|
||||
}
|
||||
if(num==0)
|
||||
break;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
ll change2(ll x,int K,int s1,ll P)
|
||||
{
|
||||
int l =0;
|
||||
for(int i=0;i<132;i++)
|
||||
{
|
||||
if((x&(1LL<<i))==0)
|
||||
{
|
||||
x|=(1LL<<i);
|
||||
l = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
int num = K+1;
|
||||
for(int i = l-1;i>=0;i--)
|
||||
{
|
||||
x-=(1LL<<i);
|
||||
num--;
|
||||
if(num==s1)
|
||||
break;
|
||||
}
|
||||
if(x>P*2)return P;
|
||||
return x;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;scanf("%d",&t);
|
||||
for(int cas = 1;cas <= t;cas ++)
|
||||
{
|
||||
ll a=read(),s1=read(),s2=read();
|
||||
ll ans = a+1;
|
||||
printf("Case #%d: ",cas);
|
||||
int len = get(ans);
|
||||
if(len<=s2&&len>=s1)
|
||||
{
|
||||
printf("%I64d\n",ans);
|
||||
continue;
|
||||
}
|
||||
if(len<s1)
|
||||
{
|
||||
printf("%I64d\n",change(ans,s1-len));
|
||||
continue;
|
||||
}
|
||||
if(len>s2)
|
||||
{
|
||||
while(len>s2)
|
||||
{
|
||||
ans = change2(ans,len,s1,a);
|
||||
len = get(ans);
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <iomanip>
|
||||
#include <string>
|
||||
#include <ctime>
|
||||
#include <list>
|
||||
#include <bitset>
|
||||
typedef unsigned char byte;
|
||||
#define pb push_back
|
||||
#define input_fast std::ios::sync_with_stdio(false);std::cin.tie(0)
|
||||
#define pi acos(-1)
|
||||
using namespace std;
|
||||
const int maxn = 30 + 10;
|
||||
int dp[maxn][maxn][2000];
|
||||
int g[maxn][maxn] , n , m , px ,dir[2][2] = {0,1,1,0},tans;
|
||||
int cal(int x,int y)
|
||||
{
|
||||
return px*x - y*y;
|
||||
}
|
||||
bool inmap(int x,int y)
|
||||
{
|
||||
return x <= n && x >= 1 && y <= m && y >= 1;
|
||||
}
|
||||
void initiation()
|
||||
{
|
||||
tans = 1 << 29;
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i = 1 ; i <= n ; ++ i)
|
||||
for(int j = 1 ; j <= m ; ++ j)
|
||||
scanf("%d",&g[i][j]);
|
||||
px = n + m - 1;
|
||||
memset(dp,-1,sizeof(dp));
|
||||
dp[1][1][g[1][1]] = g[1][1]*g[1][1];
|
||||
}
|
||||
void updata(int &x ,int v)
|
||||
{
|
||||
if(x==-1) x=v;
|
||||
else x = min(x,v);
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
for(int i = 1 ; i <= n ; ++ i)
|
||||
for(int j = 1 ; j <= m ; ++ j)
|
||||
{
|
||||
for(int z = 0 ; z <= 1900 ; ++ z)
|
||||
{
|
||||
if(dp[i][j][z] == -1) continue;
|
||||
for(int k = 0 ; k < 2 ; ++ k)
|
||||
{
|
||||
int newx = i + dir[k][0];
|
||||
int newy = j + dir[k][1];
|
||||
if(!inmap(newx,newy)) continue;
|
||||
int newval = dp[i][j][z] + g[newx][newy]*g[newx][newy];
|
||||
updata(dp[newx][newy][z+g[newx][newy]],newval);
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = 1 << 30;
|
||||
for(int i = 0 ; i <= 1900 ; ++ i) if(dp[n][m][i] != -1) ans = min(ans , px*dp[n][m][i] - i*i);
|
||||
return ans;
|
||||
}
|
||||
void dfs(int x,int y,int s1,int s2)
|
||||
{
|
||||
if(x==n&&y==m)
|
||||
{
|
||||
tans =min(tans,s1*px-s2*s2);
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int k = 0 ; k < 2 ; ++ k)
|
||||
{
|
||||
int newx = x + dir[k][0];
|
||||
int newy = y + dir[k][1];
|
||||
if(!inmap(newx,newy)) continue;
|
||||
dfs(newx,newy,s1+g[newx][newy]*g[newx][newy],s2+g[newx][newy]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(int argc,char *argv[])
|
||||
{
|
||||
int Case,cas=1;
|
||||
scanf("%d",&Case);
|
||||
while(Case--)
|
||||
{
|
||||
initiation();
|
||||
printf("Case #%d: %d\n",cas++,solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <typeinfo>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <stack>
|
||||
typedef long long ll;
|
||||
using namespace std;
|
||||
#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
|
||||
#define maxn 200006
|
||||
#define mod 1000000007
|
||||
#define eps 1e-9
|
||||
#define e exp(1.0)
|
||||
#define PI acos(-1)
|
||||
#define lowbit(x) (x)&(-x)
|
||||
const double EP = 1E-10 ;
|
||||
int Num;
|
||||
const ll inf=999999999;
|
||||
inline ll read()
|
||||
{
|
||||
ll x=0,f=1;char ch=getchar();
|
||||
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
|
||||
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
|
||||
return x*f;
|
||||
}
|
||||
int n,val1[maxn],val2[maxn];
|
||||
void add(int * vc,int u ,int v)
|
||||
{
|
||||
while(u <= n )
|
||||
{
|
||||
vc[u] += v;
|
||||
u += lowbit(u);
|
||||
}
|
||||
}
|
||||
int query(int * vc,int u)
|
||||
{
|
||||
int res=0;
|
||||
while(u)
|
||||
{
|
||||
res += vc[u];
|
||||
u -= lowbit(u);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int RankGet(int * vc,int k)
|
||||
{
|
||||
int L = 1 , R = n;
|
||||
while(L < R)
|
||||
{
|
||||
int mid = L + ((R-L)>>1);
|
||||
int res = query(vc,mid);
|
||||
if(res == k) R = mid;
|
||||
else if(res < k) L = mid + 1;
|
||||
else R = mid - 1;
|
||||
}
|
||||
return L;
|
||||
}
|
||||
struct kkk
|
||||
{
|
||||
int x,y;
|
||||
};
|
||||
bool cmp(kkk aa,kkk bb)
|
||||
{
|
||||
return aa.x<bb.x;
|
||||
}
|
||||
kkk p[maxn];
|
||||
int ans[maxn];
|
||||
vector<int> v1,v2;
|
||||
int main()
|
||||
{
|
||||
int t=read();
|
||||
for(int cas=1;cas<=t;cas++)
|
||||
{
|
||||
n=read();
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
p[i].x=read(),p[i].y=read();
|
||||
p[i].y++;
|
||||
}
|
||||
sort(p+1,p+n+1,cmp);
|
||||
int flag=1;
|
||||
memset(val1,0,4*(n+2));memset(val2,0,4*(n+2));
|
||||
for(int i = 1 ; i <= n ; ++ i)
|
||||
{
|
||||
add(val1,i,1);
|
||||
add(val2,i,1);
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(p[i].y>n-i+1)
|
||||
{
|
||||
flag=0;
|
||||
break;
|
||||
}
|
||||
int p1 = RankGet(val1,p[i].y);
|
||||
int p2 = n-RankGet(val2,p[i].y) + 1;
|
||||
if(p1<p2)
|
||||
{
|
||||
ans[p1]=p[i].x;
|
||||
add(val1,p1,-1);
|
||||
add(val2,n-p1+1,-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
ans[p2]=p[i].x;
|
||||
add(val1,p2,-1);
|
||||
add(val2,n-p2+1,-1);
|
||||
}
|
||||
}
|
||||
printf("Case #%d:",cas);
|
||||
if(!flag)
|
||||
{
|
||||
printf(" impossible\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
printf(" %d",ans[i]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-6;
|
||||
const double pi = acos(-1.0);
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int MOD = 1000000007;
|
||||
#define ll long long
|
||||
#define CL(a) memset(a,0,sizeof(a))
|
||||
int main ()
|
||||
{
|
||||
int T,n,m;
|
||||
int a[1111],b[1111];
|
||||
cin>>T;
|
||||
while (T--)
|
||||
{
|
||||
cin>>n>>m;
|
||||
for (int i=0; i<n; i++)
|
||||
cin>>a[i];
|
||||
for (int i=0; i<n; i++)
|
||||
cin>>b[i];
|
||||
sort(a, a+n);
|
||||
sort(b, b+n);
|
||||
int suma=0,sumb=0;
|
||||
for (int i=1; i<=m; i++)
|
||||
{
|
||||
suma+=a[i-1];
|
||||
sumb+=b[n-i];
|
||||
}
|
||||
if (suma>sumb)
|
||||
cout<<"YES"<<endl;
|
||||
else
|
||||
cout<<"NO"<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
#define maxn 100007
|
||||
int a[maxn],b[maxn],vis[maxn];
|
||||
int dfs(int x){
|
||||
vis[x] = 1;
|
||||
if(vis[b[a[x]]]) return 1;
|
||||
return dfs(b[a[x]])+1;
|
||||
}
|
||||
int main(){
|
||||
int t,n,u;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(int i = 1;i <= n; i++){
|
||||
scanf("%d",&u);
|
||||
a[u] = i;
|
||||
}
|
||||
for(int i = 1;i <= n; i++)
|
||||
scanf("%d",&b[i]);
|
||||
memset(vis,0,sizeof(vis));
|
||||
int ans = n;
|
||||
for(int i = 1;i <= n; i++){
|
||||
if(vis[i] == 0) {
|
||||
if(dfs(i) > 1) ans--;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL mod = 1000000007;
|
||||
const int maxn = 100005;
|
||||
int b[maxn],a[maxn];
|
||||
int n,m;
|
||||
LL cnt[maxn];
|
||||
LL B[maxn];
|
||||
int main() {
|
||||
int t;
|
||||
cin >> t;
|
||||
B[0] = 1;
|
||||
for (int i = 1;i < maxn;i++) B[i] = (B[i - 1] * 2) % mod;
|
||||
while (t--) {
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
cin >> n;
|
||||
for (int i = 0;i < n;i++) {
|
||||
scanf("%d", &a[i]);
|
||||
b[i] = a[i];
|
||||
}
|
||||
sort(b, b + n);
|
||||
m = unique(b, b + n) - b;
|
||||
LL ret = 0;
|
||||
for (int i = 0;i < n;i++) {
|
||||
int x = lower_bound(b, b + m, a[i]) - b;
|
||||
ret = ((ret - ((cnt[x] * (LL)a[i]) % mod * B[n - i - 1])%mod)%mod+mod)%mod;
|
||||
ret = (ret + B[n - 1] * (LL)a[i]) % mod;
|
||||
cnt[x] = (cnt[x] + B[i])%mod;
|
||||
}
|
||||
cout << ret << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define pr(x) cout << #x << " = " << x << " "
|
||||
#define prln(x) cout << #x << " = " << x << endl
|
||||
const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
|
||||
int n, m, a[N], b[N], c[N];
|
||||
void add(int *b, int i, int v) {
|
||||
for(; i <= n; i += i & -i) b[i] += v;
|
||||
}
|
||||
int sum(int *b, int i) {
|
||||
int ret = 0;
|
||||
for(; i; i -= i & -i) ret += b[i];
|
||||
return ret;
|
||||
}
|
||||
inline int read() {
|
||||
int c, x;
|
||||
while(c = getchar(), !isdigit(c));
|
||||
x = c - '0';
|
||||
while(c = getchar(), isdigit(c)) x = x * 10 + c - '0';
|
||||
return x;
|
||||
}
|
||||
int main() {
|
||||
ios_base::sync_with_stdio(0);
|
||||
int t; t = read();
|
||||
while(t--) {
|
||||
n = read(); m = read();
|
||||
for(int i = 1; i <= n; ++i) a[i] = read();
|
||||
memset(b, 0, sizeof b);
|
||||
memset(c, 0, sizeof c);
|
||||
long long tmp = 0;
|
||||
for(int i = m + 1; i <= n; ++i) {
|
||||
tmp += i - m - 1 - sum(c, a[i]);
|
||||
add(c, a[i], 1);
|
||||
}
|
||||
long long ans = tmp;
|
||||
for(int i = m + 1; i <= n; ++i) {
|
||||
tmp -= sum(c, a[i] - 1);
|
||||
tmp -= sum(b, n) - sum(b, a[i]);
|
||||
add(c, a[i], -1);
|
||||
tmp += sum(c, a[i - m] - 1);
|
||||
tmp += sum(b, n) - sum(b, a[i - m]);
|
||||
add(b, a[i - m], 1);
|
||||
ans = min(ans, tmp);
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
#define ll long long
|
||||
#define maxn 101
|
||||
int p;
|
||||
struct Node{
|
||||
int mat[maxn][maxn];
|
||||
void init(){
|
||||
memset(mat,0,sizeof(mat));
|
||||
}
|
||||
void one(int n){
|
||||
init();
|
||||
for(int i = 0;i < n; i++)
|
||||
mat[i][i] = 1;
|
||||
}
|
||||
int Det(int n, int mod1){
|
||||
int ans = 1;
|
||||
int *p1,*p2,mul;
|
||||
for(int i = 0;i < n; i++){
|
||||
for(int j = i+1;j < n; j++){
|
||||
while(mat[i][i] != 0 && mat[j][i] != 0){
|
||||
if(abs(mat[i][i]) > abs(mat[j][i]))
|
||||
p1=mat[i],p2=mat[j],mul=mat[i][i]/mat[j][i];
|
||||
else
|
||||
p1=mat[j],p2=mat[i],mul=mat[j][i]/mat[i][i];
|
||||
for(int l = i;l < n; l++)
|
||||
p1[l] = (p1[l]-(ll)p2[l]*mul)%mod1;
|
||||
}
|
||||
if(mat[i][i] == 0){
|
||||
ans = -ans;
|
||||
for(int l = i;l < n;l++)
|
||||
swap(mat[i][l],mat[j][l]);
|
||||
}
|
||||
}
|
||||
ans = (ll)ans*mat[i][i] % mod1;
|
||||
}
|
||||
return (ans+mod1)%mod1;
|
||||
}
|
||||
};
|
||||
int matrix[maxn][maxn];
|
||||
void multi(Node& a,Node& b,int n){
|
||||
for(int i = 0;i < n; i++)
|
||||
for(int j = 0;j < n; j++)
|
||||
matrix[i][j] = 0;
|
||||
for(int i = 0;i < n; i++){
|
||||
for(int j = 0;j < n; j++){
|
||||
if(a.mat[i][j] == 0) continue;
|
||||
for(int k = 0;k < n; k++){
|
||||
if(b.mat[j][k] == 0) continue;
|
||||
matrix[i][k] = (matrix[i][k]+(ll)a.mat[i][j]*b.mat[j][k])%p;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i = 0;i < n; i++)
|
||||
for(int j = 0;j < n; j++)
|
||||
a.mat[i][j] = matrix[i][j];
|
||||
}
|
||||
int mp[maxn][maxn];
|
||||
int main(){
|
||||
int t,n,m,q,u,v;
|
||||
Node a,b,c;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d%d%d",&n,&m,&p,&q);
|
||||
c.init();
|
||||
for(int i = 0;i < m; i++){
|
||||
scanf("%d%d",&u,&v);
|
||||
u--,v--;
|
||||
c.mat[u][u]++;
|
||||
c.mat[v][v]++;
|
||||
c.mat[u][v] = c.mat[v][u] = -1;
|
||||
}
|
||||
if(q < n-1){
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
int ans = c.Det(n-1,p);
|
||||
if(ans == 0){
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
a.init();
|
||||
b.one(n);
|
||||
for(int i = 1;i < n; i++)
|
||||
a.mat[i][i] = i,a.mat[i][i-1] = n-i;
|
||||
while(q){
|
||||
if(q&1) multi(b,a,n);
|
||||
multi(a,a,n);
|
||||
q/=2;
|
||||
}
|
||||
ans = (ll)ans*b.mat[n-1][0]%p;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define maxn 110
|
||||
class node
|
||||
{
|
||||
public:
|
||||
string sex,name;
|
||||
double sum;
|
||||
int r1,r2;
|
||||
void set(string n,string s,int o,int t)
|
||||
{
|
||||
sex=s,name=n;
|
||||
r1=o,r2=t;
|
||||
}
|
||||
}male[maxn],fe[maxn],ans[maxn];
|
||||
bool cmp(node x,node y)
|
||||
{
|
||||
return x.sum>y.sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
int n,m;
|
||||
cin>>n>>m;
|
||||
string name,sex;
|
||||
int r1,r2,rr1=0,rr2=0;
|
||||
int f=0,p=0,top=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
cin>>name>>sex>>r1>>r2;
|
||||
rr1=max(rr1,r1);
|
||||
rr2=max(rr2,r2);
|
||||
if(sex=="male") male[p++].set(name,sex,r1,r2);
|
||||
else fe[f++].set(name,sex,r1,r2);
|
||||
}
|
||||
double m1,m2;
|
||||
m1=300*1.0/rr1,m2=300*1.0/rr2;
|
||||
for(int i=0;i<p;i++)
|
||||
male[i].sum=male[i].r1*(m1)*0.3+male[i].r2*(m2)*0.7;
|
||||
for(int i=0;i<p;i++)
|
||||
fe[i].sum=fe[i].r1*(m1)*0.3+fe[i].r2*(m2)*0.7;
|
||||
sort(male,male+p,cmp);
|
||||
sort(fe,fe+f,cmp);
|
||||
if(f)
|
||||
ans[top++]=fe[0];
|
||||
for(int i=0;i<p;i++)
|
||||
{
|
||||
ans[top++]=male[i];
|
||||
}
|
||||
for(int i=0;i<f;i++)
|
||||
{
|
||||
if(fe[i].name!=ans[0].name)
|
||||
ans[top++]=fe[i];
|
||||
}
|
||||
sort(ans+1,ans+top,cmp);
|
||||
sort(ans,ans+m,cmp);
|
||||
cout<<"The member list of Shandong team is as follows:"<<endl;
|
||||
for(int i=0;i<m;i++) cout<<ans[i].name<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
#include<set>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<ctime>
|
||||
#include<bitset>
|
||||
using namespace std;
|
||||
#define N 300005
|
||||
#define NMAX 2000000000
|
||||
typedef long long ll;
|
||||
int a[22];
|
||||
bool cmp(const int& x, const int& y){
|
||||
return x>y;
|
||||
}
|
||||
int main(){
|
||||
int T, n, m;
|
||||
while ( scanf("%d", &T) != EOF){
|
||||
while ( T > 0 ){
|
||||
T--;
|
||||
scanf("%d", &n);
|
||||
int index = -1;
|
||||
for ( int i = 0 ;i < n; i++ ){
|
||||
scanf("%d", &a[i]);
|
||||
}
|
||||
int ans = 0, t = n - 1, cur = n;
|
||||
while ( t >= 0 ){
|
||||
if ( a[t] == cur ) cur--;
|
||||
t--;
|
||||
}
|
||||
cout << cur << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<iomanip>
|
||||
#include<vector>
|
||||
#include<time.h>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<iterator>
|
||||
#include<math.h>
|
||||
#include<stdlib.h>
|
||||
#include<limits.h>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<bitset>
|
||||
#define eps 1e-5
|
||||
#define INF 0x7fffffff
|
||||
#define FOR(i,a) for((i)=0;i<(a);(i)++)
|
||||
#define MEM(a) (memset((a),0,sizeof(a)))
|
||||
#define sfs(a) scanf("%s",a)
|
||||
#define sf(a) scanf("%d",&a)
|
||||
#define sfI(a) scanf("%I64d",&a)
|
||||
#define pf(a) printf("%d\n",a)
|
||||
#define pfI(a) printf("%I64d\n",a)
|
||||
#define pfs(a) printf("%s\n",a)
|
||||
#define sfd(a,b) scanf("%d%d",&a,&b)
|
||||
#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
|
||||
#define for1(i,a,b) for(int i=(a);i<b;i++)
|
||||
#define for2(i,a,b) for(int i=(a);i<=b;i++)
|
||||
#define for3(i,a,b)for(int i=(b);i>=a;i--)
|
||||
#define MEM1(a) memset(a,0,sizeof(a))
|
||||
#define MEM2(a) memset(a,-1,sizeof(a))
|
||||
#define ll long long
|
||||
const double PI=acos(-1.0);
|
||||
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
|
||||
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
|
||||
template<class T> inline T Min(T a,T b){return a<b?a:b;}
|
||||
template<class T> inline T Max(T a,T b){return a>b?a:b;}
|
||||
using namespace std;
|
||||
int n,m,L;
|
||||
#define N 50005
|
||||
#define M 1000100
|
||||
#define Mod 1000000007
|
||||
#define p(x,y) make_pair(x,y)
|
||||
int dp[5010];
|
||||
struct Node{
|
||||
int a,b,c;
|
||||
bool operator <(const Node &x) const{
|
||||
return (ll)b*x.c>(ll)x.b*c;
|
||||
}
|
||||
}e[1010];
|
||||
int main(){
|
||||
int T;
|
||||
sf(T);
|
||||
while(T--){
|
||||
int t;
|
||||
sfd(n,t);
|
||||
for(int i=1;i<=n;i++){
|
||||
scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].c);
|
||||
}
|
||||
sort(e+1,e+n+1);
|
||||
memset(dp,0,sizeof dp);
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=t;j>=e[i].c;j--){
|
||||
dp[j] = Max(dp[j],dp[j-e[i].c]+Max(0,e[i].a-j*e[i].b));
|
||||
}
|
||||
}
|
||||
int ans=-INF;
|
||||
for(int i=0;i<=t;i++)
|
||||
ans = Max(ans,dp[i]);
|
||||
pf(ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
double dp[1550];
|
||||
double power[1550];
|
||||
double ans[1550];
|
||||
double pre[1550];
|
||||
int main(){
|
||||
int T,n;
|
||||
double p,q;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d%lf%lf",&n,&p,&q);
|
||||
power[0]=1;
|
||||
double pro0=q/p;
|
||||
double pro1=(p-q)/p;
|
||||
for(int i=1;i<=n+1;i++){
|
||||
power[i]=power[i-1]*pro0;
|
||||
}
|
||||
ans[0]=0;
|
||||
n++;
|
||||
for(int i=1;i<=n;i++){
|
||||
dp[0]=pre[0]=1;
|
||||
for(int j=1;j<=n;j++){
|
||||
double now=pre[j-1];
|
||||
if(j-1-i>=0) now-=pre[j-1-i]*power[i];
|
||||
dp[j]=now*pro1;
|
||||
pre[j]=pre[j-1]*pro0+dp[j];
|
||||
}
|
||||
ans[i]=dp[n];
|
||||
}
|
||||
double e=0;
|
||||
for(int i=n;i>=1;i--){
|
||||
e+=(ans[i]-ans[i-1])*i;
|
||||
}
|
||||
e/=pro1;
|
||||
printf("%.3lf\n",e);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define N 50007
|
||||
LL c[N], s[N];
|
||||
void init() {
|
||||
for (LL i = 1; i < N; ++i)
|
||||
c[i] = i * (i - 1) >> 1;
|
||||
}
|
||||
inline int read() {
|
||||
int ret = 0;
|
||||
char ch = getchar();
|
||||
while (!('0' <= ch && ch <= '9'))
|
||||
ch = getchar();
|
||||
while ('0' <= ch && ch <= '9') {
|
||||
ret = ret * 10 + ch - '0';
|
||||
ch = getchar();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main() {
|
||||
init();
|
||||
int T = read();
|
||||
int n, i;
|
||||
LL sum;
|
||||
bool flag;
|
||||
while (T--) {
|
||||
n = read();
|
||||
for (i = 0; i < n; ++i)
|
||||
s[i] = read();
|
||||
sort(s, s + n);
|
||||
sum = 0;
|
||||
flag = true;
|
||||
for (i = 1; i <= n; ++i) {
|
||||
sum = sum + s[i - 1];
|
||||
if (sum < c[i]) {
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sum != c[n])
|
||||
flag = false;
|
||||
if (flag)
|
||||
puts("It seems to have no problem.");
|
||||
else
|
||||
puts("The data have been tampered with!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-6;
|
||||
const double pi = acos(-1.0);
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int MOD = 1000000007;
|
||||
#define ll long long
|
||||
#define CL(a) memset(a,0,sizeof(a))
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
ll n,x,sum;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
cin>>n;
|
||||
sum = 0;
|
||||
int k=0,re=0;
|
||||
ll maxx = -INF;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
cin>>x;
|
||||
if(x == 0) {re++; continue;}
|
||||
if(x < 0)
|
||||
{
|
||||
k++;
|
||||
maxx = max(maxx, x);
|
||||
}
|
||||
if(i == re) sum = x;
|
||||
else sum *= x;
|
||||
}
|
||||
if(k%2&&n!=1&&!(k==1&&re+k==n)) sum /= maxx;
|
||||
if(re>0&&(sum<0||n==1)) sum = 0;
|
||||
cout<<sum<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue