KiritoTRw
GitHub
parent
e7ac37406c
commit
9da6cdd5bd
|
|
@ -0,0 +1,115 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
#define ll long long
|
||||
struct data
|
||||
{
|
||||
int t,l,c;
|
||||
}B[3545];
|
||||
int n,r;
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<set>
|
||||
map<ll,bool > vis;
|
||||
ll s;
|
||||
inline bool check(ll s,int x)
|
||||
{
|
||||
int tx=(s&(7ll<<(x*3)))>>(x*3);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
if(i==x) continue;
|
||||
int ti=(s&(7ll<<(i*3)))>>(i*3);
|
||||
if(B[x].t==B[i].t) {
|
||||
if(B[x].c!=B[i].c) continue;
|
||||
if(tx+B[x].l<=ti||ti+B[i].l<=tx) continue;
|
||||
return 0;
|
||||
} else {
|
||||
if(tx+B[x].l>B[i].c&&B[i].c>=tx&&
|
||||
ti<=B[x].c&&B[x].c<B[i].l+ti) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
inline bool done(ll s)
|
||||
{
|
||||
for(int i=0;i<n;i++) {
|
||||
if(B[i].t==1) continue;
|
||||
int tt= ((s&(7ll<<(3*r)))>>(r*3));
|
||||
if(B[i].c<tt+B[r].l) continue;
|
||||
int l=((s&(7ll<<(3*i)))>>(i*3)) , r=l+B[i].l;
|
||||
if(r<=2||l>2) continue;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
inline void cover(ll& s,int x,int p)
|
||||
{
|
||||
s&=~(7ll<<(x*3));
|
||||
s|=(ll)p<<(x*3);
|
||||
}
|
||||
#define pii pair<ll,int>
|
||||
#define mp make_pair
|
||||
int bfs(ll s)
|
||||
{
|
||||
if(done(s)) return 1;
|
||||
queue< pii > q;
|
||||
q.push(mp(s,0));
|
||||
vis.clear();
|
||||
vis[s]=1;
|
||||
while(!q.empty()) {
|
||||
pii tt=q.front(); q.pop();
|
||||
ll u=tt.first;
|
||||
int d=tt.second+1;
|
||||
for(int i=0;i<n;i++) {
|
||||
int p=(u&(7ll<<(i*3)))>>(i*3);
|
||||
for(int j=1;j<=p;j++) {
|
||||
ll v=u;
|
||||
cover(v,i,p-j);
|
||||
if(!check(v,i)) break;
|
||||
if(done(v)) return d+1;
|
||||
if(vis[v]) continue;
|
||||
vis[v]=1;
|
||||
q.push(mp(v,d));
|
||||
}
|
||||
for(int j=1;p+j+B[i].l<=6;j++) {
|
||||
ll v=u;
|
||||
cover(v,i,p+j);
|
||||
if(!check(v,i)) break;
|
||||
if(done(v)) return d+1;
|
||||
if(vis[v]) continue;
|
||||
vis[v]=1;
|
||||
q.push(mp(v,d));
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(cin>>n&&n)
|
||||
{
|
||||
ll s=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int t,lx,ly,rx,ry;
|
||||
cin>>t>>lx>>ly>>rx>>ry;
|
||||
if(lx==rx) {
|
||||
B[i].t=0;
|
||||
B[i].l=ry-ly+1;
|
||||
B[i].c=lx;
|
||||
s|=((ll)ly<<(3*i));
|
||||
}
|
||||
else {
|
||||
B[i].t=1;
|
||||
B[i].l=rx-lx+1;
|
||||
B[i].c=ly;
|
||||
s|=((ll)lx<<(3*i));
|
||||
}
|
||||
}
|
||||
cin>>r;
|
||||
cout<<bfs(s)<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <utility>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define pb push_back
|
||||
typedef pair <int, int> pt;
|
||||
const int BUF_SIZE = 100000, SON = 26;
|
||||
char s[BUF_SIZE + 1], t[BUF_SIZE + 1];
|
||||
int lens, lent;
|
||||
vector <pt> vec;
|
||||
bool fir, las;
|
||||
struct node_t {
|
||||
node_t *son[SON], *fail;
|
||||
vector <int> lis;
|
||||
} node_pool[BUF_SIZE + 1], *node_idx, *root;
|
||||
node_t *node_alloc() {
|
||||
node_t *ret = node_idx ++;
|
||||
memset(ret -> son, 0, sizeof(ret -> son));
|
||||
ret -> fail = NULL;
|
||||
ret -> lis.clear();
|
||||
return ret;
|
||||
}
|
||||
void init() {
|
||||
node_idx = node_pool;
|
||||
root = node_alloc();
|
||||
}
|
||||
void ins(char *st, char *ed, int p) {
|
||||
node_t *pos = root;
|
||||
while (st != ed) {
|
||||
int t = *(st ++) - 'a';
|
||||
if (!pos -> son[t]) pos -> son[t] = node_alloc();
|
||||
pos = pos -> son[t];
|
||||
}
|
||||
pos -> lis.pb(p);
|
||||
}
|
||||
void build() {
|
||||
static queue <node_t *> q;
|
||||
for (int i = 0; i < SON; i ++)
|
||||
if (root -> son[i]) {
|
||||
root -> son[i] -> fail = root;
|
||||
q.push(root -> son[i]);
|
||||
}
|
||||
else root -> son[i] = root;
|
||||
while (q.size()) {
|
||||
node_t *u = q.front();
|
||||
q.pop();
|
||||
for (int i = 0; i < SON; i ++)
|
||||
if (u -> son[i]) {
|
||||
u -> son[i] -> fail = u -> fail -> son[i];
|
||||
for (vector <int>::iterator it = u -> fail -> son[i] -> lis.begin(); it != u -> fail -> son[i] -> lis.end(); it ++)
|
||||
u -> son[i] -> lis.pb(*it);
|
||||
q.push(u -> son[i]);
|
||||
}
|
||||
else u -> son[i] = u -> fail -> son[i];
|
||||
}
|
||||
}
|
||||
bool solve(int lb, int rb, bool st, bool ed) {
|
||||
init();
|
||||
int pat = 0;
|
||||
static int cnt[BUF_SIZE];
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
for (int i = lb; i < rb; )
|
||||
if (t[i] == '?') i ++;
|
||||
else {
|
||||
int j = i;
|
||||
while (j < rb && t[j] != '?') j ++;
|
||||
ins(t + i, t + j, j - 1 - lb);
|
||||
i = j;
|
||||
pat ++;
|
||||
}
|
||||
build();
|
||||
node_t *pos = root;
|
||||
for (int i = 0; i < lens; i ++) {
|
||||
int p = s[i] - 'a';
|
||||
pos = pos -> son[p];
|
||||
node_t *tmp = pos;
|
||||
for (vector <int>::iterator it = tmp -> lis.begin(); it != tmp -> lis.end(); it ++) {
|
||||
int q = *it;
|
||||
if (i - q >= 0)
|
||||
cnt[i - q] ++;
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < lens; i ++)
|
||||
if (cnt[i] == pat) {
|
||||
if (vec.empty()) {
|
||||
if (!fir && st && i != 0) continue;
|
||||
if (!las && ed && i + rb - lb != lens) continue;
|
||||
vec.pb(make_pair(i, i + rb - lb));
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
vector <pair <int, int> >::reverse_iterator it = vec.rbegin();
|
||||
if (i >= it -> second) {
|
||||
if (ed && !las && i + rb - lb != lens) continue;
|
||||
vec.pb(make_pair(i, i + rb - lb));
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main() {
|
||||
while (scanf("%s%s", s, t) != EOF) {
|
||||
lens = strlen(s), lent = strlen(t);
|
||||
fir = (t[0] == '*'), las = (t[lent - 1] == '*');
|
||||
vec.clear();
|
||||
bool fail = 0;
|
||||
int split = 0;
|
||||
int real_end = lent;
|
||||
while (real_end && t[real_end - 1] == '*') real_end --;
|
||||
for (int i = 0; i < lent; )
|
||||
if (t[i] == '*') i ++;
|
||||
else {
|
||||
int j = i;
|
||||
while (j < lent && t[j] != '*') j ++;
|
||||
if (!solve(i, j, split == 0, j == real_end)) {
|
||||
fail = 1;
|
||||
split ++;
|
||||
break;
|
||||
}
|
||||
i = j;
|
||||
split ++;
|
||||
}
|
||||
if (split == 0) printf("YES\n");
|
||||
else if (fail) printf("NO\n");
|
||||
else printf("YES\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
#define N 40005
|
||||
struct node{
|
||||
double x,y;
|
||||
}p[N];
|
||||
int n;
|
||||
double cal_dis(int x,int y){
|
||||
double x1=p[x].x,y1=p[x].y;
|
||||
double x2=p[y].x,y2=p[y].y;
|
||||
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
|
||||
}
|
||||
int main(void){
|
||||
while(~scanf("%d",&n)){
|
||||
int k=1;
|
||||
for(int i=1;i<=n;i++){
|
||||
scanf("%lf%lf",&p[k].x,&p[k].y);
|
||||
if(k!=1&&k%2){
|
||||
p[k-1].x=(p[k-2].x+p[k].x)/2.0;
|
||||
p[k-1].y=(p[k-2].y+p[k].y)/2.0;
|
||||
}
|
||||
k+=2;
|
||||
}
|
||||
p[k-1].x=(p[1].x+p[k-2].x)/2.0;
|
||||
p[k-1].y=(p[1].y+p[k-2].y)/2.0;
|
||||
bool flag=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
double x1=p[i].x-p[i+n].x;
|
||||
double y1=p[i].y-p[i+n].y;
|
||||
int j,k;
|
||||
k=i-1;
|
||||
j=i+1;
|
||||
for(;j<=i+n;j++,k--){
|
||||
if(k<=0) k=2*n;
|
||||
double x2=p[j].x-p[k].x;
|
||||
double y2=p[j].y-p[k].y;
|
||||
if(x1*x2+y1*y2!=0)
|
||||
break;
|
||||
if(cal_dis(i,j)!=cal_dis(i,k))
|
||||
break;
|
||||
}
|
||||
if(j>i+n){
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
printf("YES\n");
|
||||
else
|
||||
printf("NO\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
int main()
|
||||
{
|
||||
__int64 t, a, b, c, n, m, k;
|
||||
scanf("%I64d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&n,&m,&k);
|
||||
__int64 s = 4 * a * a * b * b - (a * a + b * b - c * c) * (a * a + b * b - c * c);
|
||||
__int64 tmp = sqrt(s);
|
||||
if(tmp * tmp == s)
|
||||
printf("YES\n");
|
||||
else
|
||||
printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include<cstdio>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int dp[1005][1005],sum[1005],a[1005],s[1005][1005];
|
||||
int main()
|
||||
{
|
||||
int n,m,r;
|
||||
while(scanf("%d%d%d",&n,&m,&r)!=EOF)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
sum[i]=sum[i-1]+a[i];
|
||||
}
|
||||
memset(dp,-1,sizeof(dp));
|
||||
memset(s,-0x1f1f1f1f,sizeof(s));
|
||||
dp[0][0]=0;s[0][0]=-sum[1];
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(i>=r)
|
||||
{
|
||||
dp[0][i]=sum[i];
|
||||
}
|
||||
dp[i][i]=0;
|
||||
s[0][i]=max(s[0][i-1],dp[0][i]-sum[i+1]);
|
||||
}
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
for(int j=i;j<=n;j++)
|
||||
{
|
||||
if(dp[i-1][j-1]!=-1)
|
||||
dp[i][j]=max(dp[i-1][j-1],dp[i][j]);
|
||||
if(j-r>=i&&s[i-1][j-r-1]!=-0x1f1f1f1f)
|
||||
dp[i][j]=max(dp[i][j],sum[j]+s[i-1][j-r-1]);
|
||||
if(dp[i][j]!=-1)
|
||||
s[i][j]=max(s[i][j-1],dp[i][j]-sum[j+1]);
|
||||
else
|
||||
s[i][j]=s[i][j-1];
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[m][n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
struct e{
|
||||
int data;
|
||||
int weight;
|
||||
e *next;
|
||||
};
|
||||
e edge[1001];
|
||||
int n;
|
||||
void add(int s,int t,int weight){
|
||||
e *p=new e;
|
||||
p->data=t;
|
||||
p->next=edge[s].next;
|
||||
p->weight=weight;
|
||||
edge[s].next=p;
|
||||
}
|
||||
int s[1001],q[1001];
|
||||
int f[1001][1001];
|
||||
int solve(int s1,int t1,int w){
|
||||
int ans1=0;
|
||||
int ans2=0;
|
||||
int i,j,k;
|
||||
if(f[s1][t1]!=-1) return f[s1][t1];
|
||||
e *p=edge[s1].next;
|
||||
e *q1=p;
|
||||
if(w>q[s1])
|
||||
{
|
||||
while(p)
|
||||
{
|
||||
solve(p->data,s1,p->weight);
|
||||
ans1+=f[p->data][s1];
|
||||
p=p->next;
|
||||
}
|
||||
f[s1][t1]=ans1+s[s1];
|
||||
}
|
||||
else
|
||||
{
|
||||
while(p)
|
||||
{
|
||||
solve(p->data,s1,p->weight);
|
||||
ans1+=f[p->data][s1];
|
||||
p=p->next;
|
||||
}
|
||||
while(q1)
|
||||
{
|
||||
solve(q1->data,t1,w+q1->weight);
|
||||
ans2+=f[q1->data][t1];
|
||||
q1=q1->next;
|
||||
}
|
||||
f[s1][t1]=min(ans2,ans1+s[s1]);
|
||||
}
|
||||
return f[s1][t1];
|
||||
}
|
||||
void read(){
|
||||
int i,j,k,s1,t,root;
|
||||
int cas;
|
||||
cin>>cas;
|
||||
while(cas--)
|
||||
{
|
||||
cin>>n;
|
||||
memset(edge,0,sizeof(edge));
|
||||
memset(f,-1,sizeof(f));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
cin>>j>>k>>s1>>t;
|
||||
if(j!=0) add(j,i,t);
|
||||
else root=i;
|
||||
q[i]=k;
|
||||
s[i]=s1;
|
||||
}
|
||||
e *p=edge[root].next;
|
||||
int ans=0;
|
||||
while(p)
|
||||
{
|
||||
ans+=solve(p->data,root,p->weight);
|
||||
p=p->next;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
read();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#define N 1000
|
||||
int co_prime[N];
|
||||
int unco_prime[N];
|
||||
int s[N];
|
||||
int Gcd(int a, int b)
|
||||
{
|
||||
return a%b?Gcd(b,a%b):b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,n,i,j,sum;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&s[i]);
|
||||
for(i=1;i<=n;i++){
|
||||
for(j=1;j<=n;j++){
|
||||
if(i == j)continue;
|
||||
if(Gcd(s[i],s[j]) == 1)co_prime[i] ++;
|
||||
else unco_prime[i] ++;
|
||||
}
|
||||
}
|
||||
sum = 0;
|
||||
for(i=1;i<=n;i++)sum += co_prime[i] * unco_prime[i];
|
||||
printf("%d\n",n*(n-1)*(n-2)/6- sum/2);
|
||||
for(i=0;i<=n;i++)co_prime[i] = unco_prime[i] = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int A,B,C;
|
||||
while(scanf("%d%d%d",&A,&B,&C)!=EOF)
|
||||
{
|
||||
double x=(double)(B+C)/(A+B+C*2);
|
||||
printf("%.6lf\n",(1-x)*B-x*C);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
struct node{
|
||||
int lone,lzero;
|
||||
int rone,rzero;
|
||||
int tmax0,tmax1;
|
||||
int flag;
|
||||
int l,r;
|
||||
int mlen;
|
||||
}p[100001*4];
|
||||
int a[100001];
|
||||
int max(int x,int y)
|
||||
{
|
||||
return x>y?x:y;
|
||||
}
|
||||
int min(int x,int y)
|
||||
{
|
||||
return x<y?x:y;
|
||||
}
|
||||
void update_info(int n)
|
||||
{
|
||||
p[n].lone=p[n*2].lone;
|
||||
if(p[n*2].lone==p[n*2].mlen)
|
||||
p[n].lone+=p[n*2+1].lone;
|
||||
p[n].lzero=p[n*2].lzero;
|
||||
if(p[n*2].lzero==p[n*2].mlen)
|
||||
p[n].lzero+=p[n*2+1].lzero;
|
||||
p[n].rone=p[n*2+1].rone;
|
||||
if(p[n*2+1].rone==p[n*2+1].mlen)
|
||||
p[n].rone+=p[n*2].rone;
|
||||
p[n].rzero=p[n*2+1].rzero;
|
||||
if(p[n*2+1].rzero==p[n*2+1].mlen)
|
||||
p[n].rzero+=p[n*2].rzero;
|
||||
p[n].tmax0=max(p[n*2].tmax0,p[n*2+1].tmax0);
|
||||
p[n].tmax0=max(p[n].tmax0,p[n*2].rzero+p[n*2+1].lzero);
|
||||
p[n].tmax1=max(p[n*2].tmax1,p[n*2+1].tmax1);
|
||||
p[n].tmax1=max(p[n].tmax1,p[n*2].rone+p[n*2+1].lone);
|
||||
}
|
||||
void build(int l,int r,int n)
|
||||
{
|
||||
p[n].l=l;
|
||||
p[n].r=r;
|
||||
p[n].flag=0;
|
||||
p[n].mlen=(r-l+1);
|
||||
if(l==r)
|
||||
{
|
||||
if(a[l]==1)
|
||||
{
|
||||
p[n].lone=1;
|
||||
p[n].lzero=0;
|
||||
p[n].rone=1;
|
||||
p[n].rzero=0;
|
||||
p[n].tmax0=0;
|
||||
p[n].tmax1=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
p[n].lone=0;
|
||||
p[n].lzero=1;
|
||||
p[n].rone=0;
|
||||
p[n].rzero=1;
|
||||
p[n].tmax0=1;
|
||||
p[n].tmax1=0;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
int mid=(l+r)/2;
|
||||
build(l,mid,n*2);
|
||||
build(mid+1,r,n*2+1);
|
||||
update_info(n);
|
||||
}
|
||||
void pushdown(int n)
|
||||
{
|
||||
p[n*2].flag=p[n*2].flag^1;
|
||||
p[n*2+1].flag=p[n*2+1].flag^1;
|
||||
swap(p[n*2].lone,p[n*2].lzero);
|
||||
swap(p[n*2].rone,p[n*2].rzero);
|
||||
swap(p[n*2].tmax1,p[n*2].tmax0);
|
||||
swap(p[n*2+1].lone,p[n*2+1].lzero);
|
||||
swap(p[n*2+1].rone,p[n*2+1].rzero);
|
||||
swap(p[n*2+1].tmax1,p[n*2+1].tmax0);
|
||||
p[n].flag=0;
|
||||
}
|
||||
void insert(int x,int y,int n)
|
||||
{
|
||||
if(x==p[n].l&&y==p[n].r)
|
||||
{
|
||||
swap(p[n].lone,p[n].lzero);
|
||||
swap(p[n].rzero,p[n].rone);
|
||||
swap(p[n].tmax1,p[n].tmax0);
|
||||
p[n].flag=p[n].flag^1;
|
||||
return ;
|
||||
}
|
||||
if(p[n].flag==1)
|
||||
pushdown(n);
|
||||
int mid=(p[n].l+p[n].r)/2;
|
||||
if(y<=mid)
|
||||
insert(x,y,n*2);
|
||||
else if(x>mid)
|
||||
insert(x,y,n*2+1);
|
||||
else
|
||||
{
|
||||
insert(x,mid,n*2);
|
||||
insert(mid+1,y,n*2+1);
|
||||
}
|
||||
update_info(n);
|
||||
}
|
||||
int sum(int x,int y,int n)
|
||||
{
|
||||
if(x==p[n].l&&y==p[n].r)
|
||||
return p[n].tmax1;
|
||||
int mid=(p[n].l+p[n].r)/2;
|
||||
if(p[n].flag==1)
|
||||
pushdown(n);
|
||||
if(y<=mid)
|
||||
return sum(x,y,n*2);
|
||||
else if(x>mid)
|
||||
return sum(x,y,n*2+1);
|
||||
else
|
||||
{
|
||||
int left=0,right=0,midden=0;
|
||||
midden=min(mid-x+1,p[n*2].rone)+min(y-mid,p[n*2+1].lone);
|
||||
left=sum(x,mid,n*2);
|
||||
right=sum(mid+1,y,n*2+1);
|
||||
return max(midden,max(left,right));
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,i,nima,x,y;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
build(1,n,1);
|
||||
scanf("%d",&m);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d",&nima,&x,&y);
|
||||
if(nima==1)
|
||||
insert(x,y,1);
|
||||
else
|
||||
printf("%d\n",sum(x,y,1));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
#include <iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<ctime>
|
||||
using namespace std;
|
||||
#define N 50009
|
||||
int R,C,ER,EC,num;
|
||||
int map1[505][505];
|
||||
int map2[505][505];
|
||||
int vis[505][505];
|
||||
struct Point
|
||||
{
|
||||
int x,y,f;
|
||||
Point(int _x,int _y,int _f){x=_x;y=_y;f=_f;}
|
||||
};
|
||||
void init()
|
||||
{
|
||||
scanf("%d%d%d%d",&R,&C,&ER,&EC);
|
||||
memset(vis,0,sizeof(vis));
|
||||
num=0;
|
||||
for(int i=0;i<2*R-1;i++)
|
||||
{
|
||||
if(i&1)
|
||||
{
|
||||
for(int j=0;j<C;j++)
|
||||
scanf("%d",&map1[i/2][j]);
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int j=0;j<C-1;j++)
|
||||
scanf("%d",&map2[i/2][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void dfs(Point s,Point ss)
|
||||
{
|
||||
int ff=s.f;
|
||||
for(;;)
|
||||
{
|
||||
if(!vis[s.x][s.y])num++;
|
||||
vis[s.x][s.y]=1;
|
||||
if(s.x==ss.x&&s.y==ss.y)
|
||||
{
|
||||
if((s.f==3&&ff==0)||(s.f==1&&ff==2))
|
||||
break;
|
||||
if(s.f==ff&&ff==0&&(s.y==0||map2[s.x][s.y-1]==1))
|
||||
break;
|
||||
if(s.f==ff&&ff==2&&(s.y==C-1||map2[s.x][s.y]==1))
|
||||
break;
|
||||
}
|
||||
if(s.f==0)
|
||||
{
|
||||
if(s.y>0&&map2[s.x][s.y-1]==0)
|
||||
{
|
||||
s.y--;
|
||||
s.f=1;
|
||||
}
|
||||
else if(s.x+1<R&&map1[s.x][s.y]==0)
|
||||
{
|
||||
s.x++;
|
||||
s.f=0;
|
||||
}
|
||||
else if(s.y+1<C&&map2[s.x][s.y]==0)
|
||||
{
|
||||
s.y++;
|
||||
s.f=3;
|
||||
}
|
||||
else if(s.x>0&&map1[s.x-1][s.y]==0)
|
||||
{
|
||||
s.x--;
|
||||
s.f=2;
|
||||
}
|
||||
}
|
||||
else if(s.f==1)
|
||||
{
|
||||
if(s.x>0&&map1[s.x-1][s.y]==0)
|
||||
{
|
||||
s.x--;
|
||||
s.f=2;
|
||||
}
|
||||
else if(s.y>0&&map2[s.x][s.y-1]==0)
|
||||
{
|
||||
s.y--;
|
||||
s.f=1;
|
||||
}
|
||||
else if(s.x+1<R&&map1[s.x][s.y]==0)
|
||||
{
|
||||
s.x++;
|
||||
s.f=0;
|
||||
}
|
||||
else if(s.y+1<C&&map2[s.x][s.y]==0)
|
||||
{
|
||||
s.y++;
|
||||
s.f=3;
|
||||
}
|
||||
}
|
||||
else if(s.f==2)
|
||||
{
|
||||
if(s.y+1<C&&map2[s.x][s.y]==0)
|
||||
{
|
||||
s.y++;
|
||||
s.f=3;
|
||||
}
|
||||
else if(s.x>0&&map1[s.x-1][s.y]==0)
|
||||
{
|
||||
s.x--;
|
||||
s.f=2;
|
||||
}
|
||||
else if(s.y>0&&map2[s.x][s.y-1]==0)
|
||||
{
|
||||
s.y--;
|
||||
s.f=1;
|
||||
}
|
||||
else if(s.x+1<R&&map1[s.x][s.y]==0)
|
||||
{
|
||||
s.x++;
|
||||
s.f=0;
|
||||
}
|
||||
}
|
||||
else if(s.f==3)
|
||||
{
|
||||
if(s.x+1<R&&map1[s.x][s.y]==0)
|
||||
{
|
||||
s.x++;
|
||||
s.f=0;
|
||||
}
|
||||
else if(s.y+1<C&&map2[s.x][s.y]==0)
|
||||
{
|
||||
s.y++;
|
||||
s.f=3;
|
||||
}
|
||||
else if(s.x>0&&map1[s.x-1][s.y]==0)
|
||||
{
|
||||
s.x--;
|
||||
s.f=2;
|
||||
}
|
||||
else if(s.y>0&&map2[s.x][s.y-1]==0)
|
||||
{
|
||||
s.y--;
|
||||
s.f=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
Point s=Point(0,ER,0);
|
||||
Point ss=Point(R-1,EC,2);
|
||||
dfs(s,ss);
|
||||
dfs(ss,s);
|
||||
if(num==R*C) puts("YES");
|
||||
else puts("NO");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int Case;
|
||||
scanf("%d",&Case);
|
||||
while(Case--)
|
||||
{
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#define MAXV 500
|
||||
#define MAXE 1000
|
||||
#define INF 0x7fffffff
|
||||
int list[MAXV];
|
||||
char s[MAXV];
|
||||
int f[MAXV + 1][26];
|
||||
bool equal[MAXV];
|
||||
int n;
|
||||
struct Edge {
|
||||
int ed, next;
|
||||
} edge[MAXE];
|
||||
int head[MAXV], nEdge;
|
||||
void init() {
|
||||
memset(head, 0xff, sizeof(head));
|
||||
nEdge = 0;
|
||||
}
|
||||
void addEdge(const int a, const int b) {
|
||||
edge[nEdge].ed = b;
|
||||
edge[nEdge].next = head[a];
|
||||
head[a] = nEdge++;
|
||||
}
|
||||
bool find(int cur, int tar){
|
||||
int i, p;
|
||||
if (cur >= n) return false;
|
||||
if (tar >= n) return true;
|
||||
for (i = head[cur]; ~i; i = edge[cur].next){
|
||||
p = edge[i].ed;
|
||||
if (p == tar) return true;
|
||||
return find(p, tar);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int imin(int a, int b){
|
||||
return a < b ? a : b;
|
||||
}
|
||||
void calc(){
|
||||
int i, j, k;
|
||||
for (i = 0; i < n - 1; i++){
|
||||
equal[i] = find(list[i + 1] + 1, list[i] + 1);
|
||||
}
|
||||
equal[i] = true;
|
||||
for (i = n - 1; i >= 0; i--){
|
||||
for (j = 0; j < 26; j++){
|
||||
f[i][j] = n + 1;
|
||||
for (k = j + 1 - equal[i]; k < 26; k++){
|
||||
f[i][j] = imin(f[i + 1][k], f[i][j]);
|
||||
}
|
||||
if (s[list[i]] != j + 'a') f[i][j]++;
|
||||
}
|
||||
}
|
||||
j = n + 1;
|
||||
for (i = 0; i < 26; i++)
|
||||
j = imin(j, f[0][i]);
|
||||
if (j > n) j = -1;
|
||||
printf("%d\n", j);
|
||||
}
|
||||
int main(){
|
||||
int i;
|
||||
while(scanf("%d", &n) != EOF){
|
||||
scanf("%s", s);
|
||||
init();
|
||||
memset(f, 0, sizeof(f));
|
||||
memset(equal, 0, sizeof(equal));
|
||||
for (i = 0; i < n; i++) scanf("%d", &list[i]);
|
||||
for (i = 0; i < n - 1; i++){
|
||||
addEdge(list[i + 1], list[i]);
|
||||
}
|
||||
calc();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#define MAXN 110
|
||||
#define MOD 1000007
|
||||
using namespace std;
|
||||
int a[MAXN], g[MAXN][MAXN];
|
||||
int Gauss(int n) {
|
||||
int i, j, r, c, cnt;
|
||||
for (c = cnt = 0; c < n; c++) {
|
||||
for (r = cnt; r < 31; r++) {
|
||||
if (g[r][c])
|
||||
break;
|
||||
}
|
||||
if (r < 31) {
|
||||
if (r != cnt) {
|
||||
for (i = 0; i < n; i++)
|
||||
swap(g[r][i], g[cnt][i]);
|
||||
}
|
||||
for (i = cnt + 1; i < 31; i++) {
|
||||
if (g[i][c]) {
|
||||
for (j = 0; j < n; j++)
|
||||
g[i][j] ^= g[cnt][j];
|
||||
}
|
||||
}
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
return n - cnt;
|
||||
}
|
||||
int main() {
|
||||
int c;
|
||||
int n, i, j;
|
||||
int ans, vary;
|
||||
scanf("%d", &c);
|
||||
while (c--) {
|
||||
scanf("%d", &n);
|
||||
for (i = 0; i < n; i++)
|
||||
scanf("%d", &a[i]);
|
||||
for (i = 0; i < 31; i++) {
|
||||
for (j = 0; j < n; j++)
|
||||
g[i][j] = (a[j] >> i) & 1;
|
||||
}
|
||||
vary = Gauss(n);
|
||||
for (ans = 1; vary--;) {
|
||||
ans <<= 1;
|
||||
ans %= MOD;
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define MAXN 10010
|
||||
#define INF 0x3fffffff
|
||||
int v[MAXN],cur[MAXN];
|
||||
int min(int x,int y)
|
||||
{
|
||||
return x<y?x:y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,t,ans;
|
||||
int i,j,s,sub;
|
||||
for(scanf("%d",&t);t;t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
if(!n)
|
||||
{
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",v+i);
|
||||
memset(cur,0,sizeof(cur));
|
||||
v[n+1]=-INF;
|
||||
for(i=1;v[i]==0;i++);
|
||||
j=i;
|
||||
s=0;
|
||||
ans=INF;
|
||||
while(i<=n)
|
||||
{
|
||||
if(i>j)
|
||||
{
|
||||
s=0;
|
||||
j=i;
|
||||
}
|
||||
while(j<=n && v[j]-cur[j]<=v[j+1])
|
||||
j++;
|
||||
if(ans>j-i+1)
|
||||
ans=j-i+1;
|
||||
sub=v[j]-cur[j]-v[j+1];
|
||||
cur[j]+=min(sub,v[i]-s);
|
||||
s+=min(sub,v[i]-s);
|
||||
while(!(v[i]-s))
|
||||
{
|
||||
s-=cur[i];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<memory.h>
|
||||
using namespace std;
|
||||
const int M=10002;
|
||||
const int INF=(1e9)-1;
|
||||
int t,n,m,tot;
|
||||
int gap[M],dis[M],pre[M],head[M],cur[M],s[M];
|
||||
int NE,NV,sink,a[M],b[M],c[M],d[M];
|
||||
struct Node
|
||||
{
|
||||
int c,pos,next;
|
||||
} E[M*4];
|
||||
#define FF(i,NV) for(int i=0;i<NV;i++)
|
||||
int sap(int s,int t)
|
||||
{
|
||||
memset(dis,0,sizeof(int)*(NV+1));
|
||||
memset(gap,0,sizeof(int)*(NV+1));
|
||||
FF(i,NV) cur[i] = head[i];
|
||||
int u = pre[s] = s,maxflow = 0,aug =INF;
|
||||
gap[0] = NV;
|
||||
while(dis[s] < NV)
|
||||
{
|
||||
loop:
|
||||
for(int &i = cur[u]; i != -1; i = E[i].next)
|
||||
{
|
||||
int v = E[i].pos;
|
||||
if(E[i].c && dis[u] == dis[v] + 1)
|
||||
{
|
||||
aug=min(aug,E[i].c);
|
||||
pre[v] = u;
|
||||
u = v;
|
||||
if(v == t)
|
||||
{
|
||||
maxflow += aug;
|
||||
for(u = pre[u]; v != s; v = u,u = pre[u])
|
||||
{
|
||||
E[cur[u]].c -= aug;
|
||||
E[cur[u]^1].c += aug;
|
||||
}
|
||||
aug =INF;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
if( (--gap[dis[u]]) == 0) break;
|
||||
int mindis = NV;
|
||||
for(int i = head[u]; i != -1 ; i = E[i].next)
|
||||
{
|
||||
int v = E[i].pos;
|
||||
if(E[i].c && mindis > dis[v])
|
||||
{
|
||||
cur[u] = i;
|
||||
mindis = dis[v];
|
||||
}
|
||||
}
|
||||
gap[ dis[u] = mindis+1 ] ++;
|
||||
u = pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
void addEdge(int u,int v,int c )
|
||||
{
|
||||
E[NE].c = c;
|
||||
E[NE].pos = v;
|
||||
E[NE].next = head[u];
|
||||
head[u] = NE++;
|
||||
E[NE].c = 0;
|
||||
E[NE].pos = u;
|
||||
E[NE].next = head[v];
|
||||
head[v] = NE++;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, m,sum, source, sink, vn,k;
|
||||
while(scanf("%d %d", &n, &m),(n||m))
|
||||
{
|
||||
NE=0,tot=0;
|
||||
sum = 0;
|
||||
source = 0;
|
||||
sink=m+1;
|
||||
NV=sink+1;
|
||||
memset(head, -1, sizeof(head));
|
||||
memset(s,0,sizeof(s));
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d",&vn);
|
||||
addEdge(source,i,vn);
|
||||
sum+=vn;
|
||||
}
|
||||
scanf("%d",&k);
|
||||
for(int i=1;i<=k;i++)
|
||||
{
|
||||
scanf("%d%d%d%d",&a[i],&b[i],&d[i],&c[i]);
|
||||
s[d[i]]+=c[i];
|
||||
}
|
||||
for(int i=1;i<=k;i++)
|
||||
{
|
||||
for(int j=1;j<=k;j++)
|
||||
{
|
||||
if(i!=j&&b[i]==a[j]&&d[i]!=d[j])
|
||||
{
|
||||
addEdge(d[i],d[j],INF);
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
addEdge(i,sink,s[i]);
|
||||
}
|
||||
printf("%d\n",sum-sap(source,sink));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <memory.h>
|
||||
#include <cmath>
|
||||
#define MAXN 300
|
||||
#define eps 1e-5
|
||||
#define max(a,b) (a>b?a:b)
|
||||
#define min(a,b) (a<b?a:b)
|
||||
using namespace std;
|
||||
struct point {double x,y;};
|
||||
struct point pnt[MAXN],ll[MAXN],rr[MAXN],center;
|
||||
int N,M,l_pos,r_pos;
|
||||
double ans,H;
|
||||
bool ne;
|
||||
point bcenter(point pnt[], int n)
|
||||
{
|
||||
point p, s;
|
||||
if(n==1)
|
||||
return pnt[0];
|
||||
if(n==2)
|
||||
{
|
||||
s.x=(pnt[0].x+pnt[1].x)/2;
|
||||
s.y=(pnt[0].y+pnt[1].y)/2;
|
||||
return s;
|
||||
}
|
||||
double tp, area = 0, tpx = 0, tpy = 0;
|
||||
p.x = pnt[0].x; p.y = pnt[0].y;
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{ // point: 0 ~ n-1
|
||||
s.x = pnt[(i == n) ? 0 : i].x;
|
||||
s.y = pnt[(i == n) ? 0 : i].y;
|
||||
tp = (p.x * s.y - s.x * p.y); area += tp / 2;
|
||||
tpx += (p.x + s.x) * tp; tpy += (p.y + s.y) * tp;
|
||||
p.x = s.x; p.y = s.y;
|
||||
}
|
||||
s.x = tpx / (6 * area); s.y = tpy / (6 * area);
|
||||
return s;
|
||||
}
|
||||
void Print()
|
||||
{
|
||||
int i;
|
||||
printf("-------------------------------------\n");
|
||||
for(i=0;i<M;i++)
|
||||
printf("%.2lf %.2lf\n",ll[i].x,ll[i].y);
|
||||
for(i=0;i<N;i++)
|
||||
printf("%.2lf %.2lf\n",rr[i].x,rr[i].y);
|
||||
printf("-------------------------------------\n");
|
||||
}
|
||||
point get_point(point c,point a,point b)
|
||||
{
|
||||
point res;
|
||||
double dx,dy;
|
||||
dx=fabs(a.x-b.x);
|
||||
dy=b.y-a.y;
|
||||
res.y=c.y;
|
||||
if(fabs(a.x-b.x)<=eps)
|
||||
res.x=a.x;
|
||||
else
|
||||
{
|
||||
if(a.x<b.x)
|
||||
res.x=dx*(c.y-a.y)*1.0/dy+a.x;
|
||||
else
|
||||
res.x=a.x-dx*(c.y-a.y)*1.0/dy;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void ini()
|
||||
{
|
||||
M=N=0;
|
||||
l_pos=r_pos=0;
|
||||
ans=H=0;
|
||||
memset(pnt,0,sizeof(pnt));
|
||||
memset(ll,0,sizeof(ll));
|
||||
memset(rr,0,sizeof(rr));
|
||||
}
|
||||
void Init()
|
||||
{
|
||||
int i;
|
||||
ini();
|
||||
scanf("%d%d",&M,&N);
|
||||
for(i=0;i<M;i++)
|
||||
scanf("%lf%lf",&ll[i].x,&ll[i].y);
|
||||
for(i=0;i<N;i++)
|
||||
scanf("%lf%lf",&rr[i].x,&rr[i].y);
|
||||
}
|
||||
bool Judge(point o)
|
||||
{
|
||||
if((o.x-ll[0].x>=eps)&&(rr[0].x-o.x>=eps))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
bool fuck(double mid,int l_pos,int r_pos)
|
||||
{
|
||||
int i;
|
||||
point temp,now1,now2;
|
||||
temp.x=1;temp.y=mid;
|
||||
int cnt=0;
|
||||
if(fabs(ll[l_pos].y-rr[r_pos].y)<=eps)
|
||||
{
|
||||
for(i=l_pos;i>=0;i--)
|
||||
pnt[cnt++]=ll[i];
|
||||
for(i=0;i<=r_pos;i++)
|
||||
pnt[cnt++]=rr[i];
|
||||
}
|
||||
else if(ll[l_pos].y<rr[r_pos].y)
|
||||
{
|
||||
now1=get_point(temp,ll[l_pos],ll[l_pos+1]);
|
||||
now2=get_point(temp,rr[r_pos-1],rr[r_pos]);
|
||||
pnt[cnt++]=now1;
|
||||
for(i=l_pos;i>=0;i--)
|
||||
pnt[cnt++]=ll[i];
|
||||
for(i=0;i<r_pos;i++)
|
||||
pnt[cnt++]=rr[i];
|
||||
pnt[cnt++]=now2;
|
||||
}
|
||||
else
|
||||
{
|
||||
now1=get_point(temp,ll[l_pos-1],ll[l_pos]);
|
||||
now2=get_point(temp,rr[r_pos],rr[r_pos+1]);
|
||||
pnt[cnt++]=now1;
|
||||
for(i=l_pos-1;i>=0;i--)
|
||||
pnt[cnt++]=ll[i];
|
||||
for(i=0;i<=r_pos;i++)
|
||||
pnt[cnt++]=rr[i];
|
||||
pnt[cnt++]=now2;
|
||||
}
|
||||
center=bcenter(pnt,cnt);
|
||||
return Judge(center);
|
||||
}
|
||||
void Solve()
|
||||
{
|
||||
ans=ll[0].y;;
|
||||
double l,r,mid;
|
||||
int i,cnt;
|
||||
point now;
|
||||
l_pos=r_pos=1;
|
||||
while(true)
|
||||
{
|
||||
cnt=0;
|
||||
if(l_pos==M||r_pos==N) break;
|
||||
if(ll[l_pos].y<=rr[r_pos].y)
|
||||
{
|
||||
for(i=l_pos;i>=0;i--)
|
||||
pnt[cnt++]=ll[i];
|
||||
for(i=0;i<r_pos;i++)
|
||||
pnt[cnt++]=rr[i];
|
||||
now=get_point(ll[l_pos],rr[r_pos-1],rr[r_pos]);
|
||||
pnt[cnt++]=now;
|
||||
center=bcenter(pnt,cnt);
|
||||
ne=Judge(center);
|
||||
if(!ne)
|
||||
{
|
||||
l=max(rr[r_pos-1].y,ll[l_pos-1].y);r=ll[l_pos].y;
|
||||
while(fabs(l-r)>eps)
|
||||
{
|
||||
mid=(l+r)/2.0;
|
||||
if(fuck(mid,l_pos,r_pos-1))
|
||||
l=mid;
|
||||
else
|
||||
r=mid;
|
||||
}
|
||||
ans=max(ans,l);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans=max(ans,ll[l_pos].y);
|
||||
l_pos++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
now=get_point(rr[r_pos],ll[l_pos-1],ll[l_pos]);
|
||||
pnt[cnt++]=now;
|
||||
for(i=l_pos-1;i>=0;i--)
|
||||
pnt[cnt++]=ll[i];
|
||||
for(i=0;i<=r_pos;i++)
|
||||
pnt[cnt++]=rr[i];
|
||||
center=bcenter(pnt,cnt);
|
||||
ne=Judge(center);
|
||||
if(!ne)
|
||||
{
|
||||
l=max(ll[l_pos-1].y,rr[r_pos-1].y);r=rr[r_pos].y;
|
||||
while(fabs(l-r)>eps)
|
||||
{
|
||||
mid=(l+r)/2.0;
|
||||
if(fuck(mid,l_pos-1,r_pos))
|
||||
l=mid;
|
||||
else
|
||||
r=mid;
|
||||
}
|
||||
ans=max(ans,l);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans=max(ans,rr[r_pos].y);
|
||||
r_pos++;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%.3lf\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
Init();
|
||||
Solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
double dis[21][21],dp[1<<21];
|
||||
int n,fx,fy,mac;
|
||||
struct node
|
||||
{
|
||||
int x,y;
|
||||
}nd[21];
|
||||
double DIS(double x,double y,double xx,double yy)
|
||||
{
|
||||
return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
|
||||
}
|
||||
bool cmp(node a,node b)
|
||||
{
|
||||
return DIS(a.x,a.y,fx,fy)<DIS(b.x,b.y,fx,fy);
|
||||
}
|
||||
double DP(int sta)
|
||||
{
|
||||
if(dp[sta]!=0x7fffffff)
|
||||
return dp[sta];
|
||||
if(sta==0) {dp[0]=0.0;}
|
||||
else
|
||||
{
|
||||
int tem=sta,i=0;
|
||||
for(i=0;i<20;i++)
|
||||
{
|
||||
if((1<<i)&sta)break;
|
||||
}
|
||||
for(int j=i+1;j<2*n;j++)
|
||||
{
|
||||
if((sta&(1<<j))==0)continue;
|
||||
dp[sta]=min(DP(sta-(1<<j)-(1<<i))+dis[i][j],dp[sta]);
|
||||
}
|
||||
}
|
||||
return dp[sta];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int c,ca=0;
|
||||
scanf("%d",&c);
|
||||
while(c--)
|
||||
{
|
||||
ca++;
|
||||
scanf("%d%d",&fx,&fy);
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<2*n;i++)
|
||||
{
|
||||
scanf("%d%d",&nd[i].x,&nd[i].y);
|
||||
}
|
||||
sort(nd,nd+2*n,cmp);
|
||||
for(int i=0;i<2*n;i++)
|
||||
for(int j=i+1;j<2*n;j++)
|
||||
{
|
||||
dis[i][j]=DIS(nd[i].x,nd[i].y,fx,fy)+DIS(nd[i].x*1.0,nd[i].y*1.0,nd[j].x*1.0,nd[j].y*1.0);
|
||||
}
|
||||
printf("Case #%d: ",ca);
|
||||
for(int i=0;i<(1<<2*n);i++)
|
||||
dp[i]=0x7fffffff;
|
||||
printf("%.2f\n",DP((1<<(2*n))-1));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,155 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
double x, y;
|
||||
} node[201];
|
||||
struct T_T
|
||||
{
|
||||
int id;
|
||||
double dis;
|
||||
} que[201];
|
||||
double sx, sy;
|
||||
double ans;
|
||||
double dis[201];
|
||||
double map[201][201];
|
||||
int q[201][201], q2[201][201];
|
||||
int n;
|
||||
int m;
|
||||
bool vis[201];
|
||||
int ra, rb, rc, rd;
|
||||
double rmin;
|
||||
double rdis;
|
||||
double dist(int i, int j)
|
||||
{
|
||||
return sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x)
|
||||
+ (node[i].y - node[j].y) * (node[i].y - node[j].y));
|
||||
}
|
||||
bool cmp(T_ a, T_ b)
|
||||
{
|
||||
return a.dis < b.dis;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
for(int i = 0; i < m; i++) dis[i] = dist(i, m);
|
||||
for(int i = 0; i < m; i++)
|
||||
for(int j = i + 1; j < m; j++)
|
||||
map[i][j] = map[j][i] = dist(i, j);
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
int temp = 0;
|
||||
for(int j = 0; j < m; j++)
|
||||
if(i != j)
|
||||
{
|
||||
que[temp].id = j;
|
||||
que[temp].dis = dis[j] + map[j][i];
|
||||
temp++;
|
||||
}
|
||||
sort(que, que + temp, cmp);
|
||||
for(int j = 0; j < temp; j++)
|
||||
q[i][j] = que[j].id;
|
||||
}
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
int temp = 0;
|
||||
for(int j = 0; j < m; j++)
|
||||
if(i != j)
|
||||
{
|
||||
que[temp].id = j;
|
||||
que[temp].dis = map[i][j];
|
||||
temp++;
|
||||
}
|
||||
sort(que, que + temp, cmp);
|
||||
for(int j = 0; j < temp; j++)
|
||||
q2[i][j] = que[j].id;
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
rmin = -1;
|
||||
int a, b, c, d;
|
||||
for(b = 0; b < m; b++)
|
||||
if(!vis[b])
|
||||
{
|
||||
for(c = 0; c < m; c++)
|
||||
if(!vis[c] && b != c)
|
||||
{
|
||||
int t = 0;
|
||||
a = q[b][t];
|
||||
while(vis[a] || a == c)
|
||||
{
|
||||
t++;
|
||||
a = q[b][t];
|
||||
}
|
||||
t = 0;
|
||||
d = q2[c][t];
|
||||
while(vis[d] || d == a || d == b)
|
||||
{
|
||||
t++;
|
||||
d = q2[c][t];
|
||||
}
|
||||
double cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
|
||||
double cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
|
||||
if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
|
||||
{
|
||||
rmin = cou;
|
||||
rdis = cdis;
|
||||
ra = a, rb = b, rc = c, rd = d;
|
||||
}
|
||||
t = 0;
|
||||
d = q2[c][t];
|
||||
while(vis[d] || d == b)
|
||||
{
|
||||
t++;
|
||||
d = q2[c][t];
|
||||
}
|
||||
t = 0;
|
||||
a = q[b][t];
|
||||
while(vis[a] || a == c || a == d)
|
||||
{
|
||||
t++;
|
||||
a = q[b][t];
|
||||
}
|
||||
cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
|
||||
cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
|
||||
if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
|
||||
{
|
||||
rmin = cou;
|
||||
rdis = cdis;
|
||||
ra = a, rb = b, rc = c, rd = d;
|
||||
}
|
||||
}
|
||||
}
|
||||
vis[ra] = 1;
|
||||
vis[rb] = 1;
|
||||
vis[rc] = 1;
|
||||
vis[rd] = 1;
|
||||
ans += rmin;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int cas = 1;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%lf%lf", &sx, &sy);
|
||||
scanf("%d", &n);
|
||||
m = 4 * n;
|
||||
for(int i = 0; i < m; i++) scanf("%lf%lf", &node[i].x, &node[i].y);
|
||||
node[m].x = sx;
|
||||
node[m].y = sy;
|
||||
init();
|
||||
ans = 0;
|
||||
memset(vis, 0, sizeof(vis));
|
||||
for(int i = 0; i < n; i++)
|
||||
{
|
||||
solve();
|
||||
}
|
||||
printf("Case #%d: %0.2lf\n", cas++, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int mod=1000000007;
|
||||
__int64 n,c;
|
||||
__int64 fun(__int64 a,__int64 b)
|
||||
{
|
||||
__int64 t=1,y=a;
|
||||
for(int i=1;i<=b;i*=2)
|
||||
{
|
||||
if(b&i)
|
||||
t=t*y%mod;
|
||||
y=y*y%mod;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
__int64 euler(__int64 a)
|
||||
{
|
||||
__int64 ans=a;
|
||||
for(int i=2;i<=a;i++)
|
||||
{
|
||||
if(a%i==0)
|
||||
ans-=ans/i;
|
||||
while(a%i==0)
|
||||
a/=i;
|
||||
}
|
||||
if(a>1)
|
||||
ans-=ans/a;
|
||||
return ans;
|
||||
}
|
||||
__int64 Extend_euclid(__int64 a,__int64 b,__int64 &x,__int64 &y)
|
||||
{
|
||||
__int64 d=0,t=0;
|
||||
if(b==0)
|
||||
{
|
||||
x=1;
|
||||
y=0;
|
||||
return a;
|
||||
}
|
||||
else
|
||||
{
|
||||
d=Extend_euclid(b,a%b,x,y);
|
||||
t=x;
|
||||
x=y;
|
||||
y=t-a/b*y;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
__int64 Bignum_Div(__int64 a,__int64 b)
|
||||
{
|
||||
__int64 x=0,y=0;
|
||||
Extend_euclid(b,mod,x,y);
|
||||
__int64 ans= a*x%mod;
|
||||
while(ans<0)
|
||||
ans+=mod;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 ans=0,t=1,T=0;
|
||||
scanf("%I64d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d %I64d",&c,&n);
|
||||
ans=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(n%i==0)
|
||||
{
|
||||
ans+=fun(c,i)*euler(n/i);
|
||||
ans%=mod;
|
||||
}
|
||||
}
|
||||
if(n&1)
|
||||
{
|
||||
ans+=n*fun(c,n/2+1);
|
||||
ans%=mod;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans+=n/2*( fun(c,n/2)+fun(c,n/2+1));
|
||||
ans%=mod;
|
||||
}
|
||||
ans=Bignum_Div(ans,2*n);
|
||||
printf("Case #%I64d: %I64d\n",t++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
typedef __int64 LL;
|
||||
const int MAX=30;
|
||||
const int LIM=21;
|
||||
LL num[MAX],rig[MAX],total[MAX];
|
||||
int b[4];
|
||||
LL gs(int L)
|
||||
{
|
||||
LL res=0;
|
||||
for(int i=0;i<=L;i++)
|
||||
{
|
||||
for(int j=i;j<=L;j++)
|
||||
{
|
||||
int k=L-i-j;
|
||||
if(j>k) continue;
|
||||
b[0]=i;
|
||||
b[1]=j;
|
||||
b[2]=k;
|
||||
do
|
||||
{
|
||||
res+=num[b[0]]*num[b[1]]*num[b[2]];
|
||||
}while(next_permutation(b,b+3));
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
LL getR(int L)
|
||||
{
|
||||
LL res=0;
|
||||
for(int i=0;i<=L;i++)
|
||||
{
|
||||
res+=num[i]*num[L-i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
num[0]=num[1]=1;
|
||||
for(int i=2;i<=LIM;i++) num[i]=gs(i-1);
|
||||
total[0]=0;
|
||||
for(int i=1;i<=LIM;i++) total[i]=total[i-1]+num[i];
|
||||
rig[0]=1;
|
||||
for(int i=1;i<=LIM;i++) rig[i]=getR(i);
|
||||
}
|
||||
int getNN(LL N)
|
||||
{
|
||||
for(int i=1;i<=LIM;i++) if(total[i]>=N) return i;
|
||||
}
|
||||
void dfs(int L,LL N)
|
||||
{
|
||||
if(L==1) {printf("X");return ;}
|
||||
int x=L-1;
|
||||
int ll,mm,rr;
|
||||
for(ll=0;N>num[ll]*rig[x-ll];ll++) N-=num[ll]*rig[x-ll];
|
||||
if(ll)
|
||||
{
|
||||
printf("(");
|
||||
dfs(ll,(N-1)/rig[x-ll]+1);
|
||||
printf(")");
|
||||
}
|
||||
N%=rig[x-ll];
|
||||
if(N==0) N=rig[x-ll];
|
||||
x-=ll;
|
||||
for(mm=0;N>num[mm]*num[x-mm];mm++) N-=num[mm]*num[x-mm];
|
||||
if(mm)
|
||||
{
|
||||
printf("(");
|
||||
dfs(mm,(N-1)/num[x-mm]+1);
|
||||
printf(")");
|
||||
}
|
||||
N%=num[x-mm];
|
||||
if(N==0) N=num[x-mm];
|
||||
x-=mm;
|
||||
if(x)
|
||||
{
|
||||
printf("(");
|
||||
dfs(x,N);
|
||||
printf(")");
|
||||
}
|
||||
printf("X");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int T;scanf("%d",&T);
|
||||
int CN=0;
|
||||
while(T--)
|
||||
{
|
||||
LL N;scanf("%I64d",&N);
|
||||
int nn=getNN(N);
|
||||
printf("Case #%d: ",++CN);
|
||||
dfs(nn,N-total[nn-1]);
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 100 + 10;
|
||||
bool cmp(char *s, int high, int low, char *sub)
|
||||
{
|
||||
int j = 0;
|
||||
for(int i = high; i <= low; i++) if(s[i] != sub[j++]) return 0;
|
||||
return 1;
|
||||
}
|
||||
int cmpp(char *a, char *b)
|
||||
{
|
||||
int len_a = strlen(a), len_b = strlen(b), len = min(len_a, len_b), i;
|
||||
if(len_a != len_b)
|
||||
{
|
||||
if(len_a > len_b) return 1;
|
||||
else return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
if(a[i] > b[i]) return 1;
|
||||
if(a[i] < b[i]) return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
int to_int(char *s, int high, int low)
|
||||
{
|
||||
int ret = 0;
|
||||
for(int i = high; i <= low; i++) ret = ret*10 + s[i]-'0';
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j, k, u, v, cnt = 1, T;
|
||||
char a[maxn], b[maxn], B[maxn], c[maxn], minn[maxn];
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s%s", a, b);
|
||||
int len_a = strlen(a), len_b = strlen(b);
|
||||
for(i = 0; i < maxn; i++) minn[i] = '9';
|
||||
for(i = len_b; i < maxn; i++) b[i] = '0'; b[maxn-1] = 0;
|
||||
int bb = to_int(b, 0, len_b-1);
|
||||
if(len_a < len_b)
|
||||
{
|
||||
int aa = to_int(a, 0, len_a-1);
|
||||
printf("Case #%d: %d\n", cnt++, bb-aa);
|
||||
continue;
|
||||
}
|
||||
bool ok = 0;
|
||||
for(i = len_a-len_b; i >= 0; i--)
|
||||
{
|
||||
int aa = to_int(a, i, i+len_b-1);
|
||||
if(aa == bb)
|
||||
{
|
||||
ok = 1;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(u = 0; u < maxn; u++) B[u] = b[u];
|
||||
for(j = len_a-1, k = len_a-1-i; j >= i; j--, k--)
|
||||
{
|
||||
if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
|
||||
else
|
||||
{
|
||||
if(k-1 >= 0) B[k-1]--;
|
||||
c[k] = B[k] + 10 - a[j] + '0';
|
||||
}
|
||||
}
|
||||
c[len_a-i] = 0;
|
||||
for(v = 0; v < len_a-i; v++) if(c[v] != '0') break;
|
||||
if(v != 0) for(u = 0; v <= len_a-i; u++,v++) c[u] = c[v];
|
||||
if(cmpp(c, minn) < 0) for(u = 0; u <= len_a-i; u++) minn[u] = c[u];
|
||||
}
|
||||
}
|
||||
if(ok) printf("Case #%d: %d\n", cnt++, 0);
|
||||
else
|
||||
{
|
||||
for(u = 0; u < maxn; u++) B[u] = b[u];
|
||||
for(j = len_a-1, k = len_a; j >= 0; j--, k--)
|
||||
{
|
||||
if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
|
||||
else
|
||||
{
|
||||
B[k-1]--;
|
||||
c[k] = B[k] + 10 - a[j] + '0';
|
||||
}
|
||||
}
|
||||
c[0] = B[0];
|
||||
c[len_a+1] = 0;
|
||||
for(v = 0; v < len_a+1; v++) if(c[v] != '0') break;
|
||||
if(v != 0) for(u = 0; v <= len_a+1; u++,v++) c[u] = c[v];
|
||||
if(cmpp(c, minn) == -1) for(u = 0; u <= len_a+1; u++) minn[u] = c[u];
|
||||
printf("Case #%d: %s\n", cnt++, minn);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<climits>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 10010
|
||||
int pre1[MAXN], pre2[MAXN];
|
||||
int num1, num2;
|
||||
struct graph
|
||||
{
|
||||
int son;
|
||||
bool ring;
|
||||
};
|
||||
graph g1[MAXN], g2[MAXN];
|
||||
bool cmb(const graph &g1, const graph &g2)
|
||||
{
|
||||
if(g1.son < g2.son)
|
||||
return true;
|
||||
else if(g1.son == g2.son && g1.ring < g2.ring)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
int find(int x, int pre[])
|
||||
{
|
||||
return x == pre[x] ? x : find(pre[x], pre);
|
||||
}
|
||||
void join(int x, int y, int pre[],graph g1[])
|
||||
{
|
||||
int root1, root2;
|
||||
root1 = find(x, pre);
|
||||
root2 = find(y, pre);
|
||||
if(root1 == root2)
|
||||
g1[root1].ring = true;
|
||||
else
|
||||
{
|
||||
if(g1[root1].son >= g1[root2].son)
|
||||
{
|
||||
pre[root2] = root1;
|
||||
g1[root1].son += g1[root2].son;
|
||||
}
|
||||
else
|
||||
{
|
||||
pre[root1] = root2;
|
||||
g1[root2].son += g1[root1].son;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool cmp(int num, graph g1[], graph g2[])
|
||||
{
|
||||
sort(g1 + 1, g1 + num + 1, cmb);
|
||||
sort(g2 + 1, g2 + num + 1, cmb);
|
||||
for(int i = 1; i <= num; ++i)
|
||||
if(g1[i].son != g2[i].son || (g1[i].son == g2[i].son && g1[i].ring != g2[i].ring))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase, T = 0;
|
||||
int link1, link2;
|
||||
int hand1, hand2;
|
||||
int ans1, ans2;
|
||||
bool flag;
|
||||
scanf("%d", &ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
flag = true;
|
||||
scanf("%d%d", &num1, &link1);
|
||||
for(int i = 1; i < MAXN; ++i)
|
||||
{
|
||||
pre1[i] = i;
|
||||
pre2[i] = i;
|
||||
g1[i].son = 1;
|
||||
g2[i].son = 1;
|
||||
g1[i].ring = false;
|
||||
g2[i].ring = false;
|
||||
}
|
||||
for(int i = 1; i <= link1; ++i)
|
||||
{
|
||||
scanf("%d%d", &hand1, &hand2);
|
||||
join(hand1, hand2, pre1, g1);
|
||||
}
|
||||
scanf("%d%d", &num2, &link2);
|
||||
if(link2 != link1)
|
||||
flag = false;
|
||||
for(int i = 1; i <= link2; ++i)
|
||||
{
|
||||
scanf("%d%d", &hand1, &hand2);
|
||||
if(flag == false)
|
||||
continue;
|
||||
else
|
||||
join(hand1, hand2, pre2, g2);
|
||||
}
|
||||
flag = cmp(num2, g1, g2);
|
||||
if(flag == false)
|
||||
printf("Case #%d: NO\n", ++T);
|
||||
else
|
||||
{
|
||||
if(flag)
|
||||
printf("Case #%d: YES\n", ++T);
|
||||
else
|
||||
printf("Case #%d: NO\n", ++T);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#define ll long long
|
||||
using namespace std;
|
||||
const int N = 200;
|
||||
int mtx[N][N], n;
|
||||
int row[N], col[N], dia[2];
|
||||
map<int, int> M;
|
||||
int cunt;
|
||||
void Change(int r1, int c1, int r2, int c2) {
|
||||
int d = mtx[r1][c1] - mtx[r2][c2];
|
||||
if (d == 0) return;
|
||||
int res = 0;
|
||||
if ((M[row[r1]]--) == 1) res--;
|
||||
if ((M[col[c1]]--) == 1) res--;
|
||||
if ((M[row[r2]]--) == 1) res--;
|
||||
if ((M[col[c2]]--) == 1) res--;
|
||||
if (r1 == c1 && (M[dia[0]]--) == 1) res--;
|
||||
if (r1 == n - c1 - 1 && (M[dia[1]]--) == 1) res--;
|
||||
if (r2 == c2 && (M[dia[0]]--) == 1) res--;
|
||||
if (r2 == n - c2 - 1 && (M[dia[1]]--) == 1) res--;
|
||||
swap(mtx[r1][c1], mtx[r2][c2]);
|
||||
row[r1] -= d; col[c1] -= d; row[r2] += d; col[c2] += d;
|
||||
if (r1 == c1) dia[0] -= d;
|
||||
if (r1 == n - c1 - 1) dia[1] -= d;
|
||||
if (r2 == c2) dia[0] += d;
|
||||
if (r2 == n - c2 - 1) dia[1] += d;
|
||||
if ((M[row[r1]]++) == 0) res++;
|
||||
if ((M[col[c1]]++) == 0) res++;
|
||||
if ((M[row[r2]]++) == 0) res++;
|
||||
if ((M[col[c2]]++) == 0) res++;
|
||||
if (r1 == c1 && (M[dia[0]]++) == 0) res++;
|
||||
if (r1 == n - c1 - 1 && (M[dia[1]]++) == 0) res++;
|
||||
if (r2 == c2 && (M[dia[0]]++) == 0) res++;
|
||||
if (r2 == n - c2 - 1 && (M[dia[1]]++) == 0) res++;
|
||||
if (res >= 0) {
|
||||
cunt += res;
|
||||
return;
|
||||
}
|
||||
M[row[r1]]--; M[col[c1]]--; M[row[r2]]--; M[col[c2]]--;
|
||||
if (r1 == c1) M[dia[0]]--;
|
||||
if (r1 == n - c1 - 1) M[dia[1]]--;
|
||||
if (r2 == c2) M[dia[0]]--;
|
||||
if (r2 == n - c2 - 1) M[dia[1]]--;
|
||||
swap(mtx[r1][c1], mtx[r2][c2]);
|
||||
row[r1] += d; col[c1] += d; row[r2] -= d; col[c2] -= d;
|
||||
if (r1 == c1) dia[0] += d;
|
||||
if (r1 == n - c1 - 1) dia[1] += d;
|
||||
if (r2 == c2) dia[0] -= d;
|
||||
if (r2 == n - c2 - 1) dia[1] -= d;
|
||||
M[row[r1]]++; M[col[c1]]++; M[row[r2]]++; M[col[c2]]++;
|
||||
if (r1 == c1) M[dia[0]]++;
|
||||
if (r1 == n - c1 - 1) M[dia[1]]++;
|
||||
if (r2 == c2) M[dia[0]]++;
|
||||
if (r2 == n - c2 - 1) M[dia[1]]++;
|
||||
}
|
||||
int main() {
|
||||
int T, C, m, idx, s1, s2;
|
||||
int r1, c1, r2, c2;
|
||||
scanf("%d", &T);
|
||||
for (C = 1; C <= T; C++) {
|
||||
scanf("%d", &n);
|
||||
idx = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = 0; j < n; j++)
|
||||
mtx[i][j] = ++idx;
|
||||
M.clear();
|
||||
cunt = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
s1 = 0, s2 = 0;
|
||||
for (int j = 0; j < n; j++) {
|
||||
s1 += mtx[i][j];
|
||||
s2 += mtx[j][i];
|
||||
}
|
||||
row[i] = s1; col[i] = s2;
|
||||
if ((M[s1]++) == 0) cunt++;
|
||||
if ((M[s2]++) == 0) cunt++;
|
||||
}
|
||||
s1 = s2 = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
s1 += mtx[i][i];
|
||||
s2 += mtx[i][n-i-1];
|
||||
}
|
||||
dia[0] = s1; dia[1] = s2;
|
||||
if ((M[s1]++) == 0) cunt++;
|
||||
if ((M[s2]++) == 0) cunt++;
|
||||
m = 2 * n + 2;
|
||||
while (cunt < m) {
|
||||
r1 = rand() % n;
|
||||
r2 = rand() % n;
|
||||
c1 = rand() % n;
|
||||
c2 = rand() % n;
|
||||
Change(r1, c1, r2, c2);
|
||||
}
|
||||
printf("Case #%d:\n", C);
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (j) printf(" ");
|
||||
printf("%d", mtx[i][j]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#define Maxn 100
|
||||
#define inf 1<<30
|
||||
using namespace std;
|
||||
int T, n, f[Maxn][Maxn], out[Maxn][Maxn];
|
||||
int le[Maxn], ri[Maxn];
|
||||
int dfs(int x, int y)
|
||||
{
|
||||
if (f[x][y] != -1) return f[x][y];
|
||||
if (out[x][y] == 1) return f[x][y] = 0;
|
||||
int t1, t2, t3, tmp = inf;
|
||||
for (int i=1; i<=n; i++)
|
||||
{
|
||||
t1 = t2 = t3 = -inf;
|
||||
int x1 = x, yy1 = min(le[i]-1, y);
|
||||
if (yy1 == y) continue;
|
||||
if (x1 <= yy1 && out[x1][yy1]) t1 = dfs(x1, yy1);
|
||||
int x2 = max(le[i]+1, x), y2 = min(ri[i]-1, y);
|
||||
if (x2 == x && y2 == y) continue;
|
||||
if (x2 <= y2 && out[x2][y2]) t2 = dfs(x2, y2);
|
||||
int x3 = max(ri[i], x), y3 = y;
|
||||
if (x3 == x) continue;
|
||||
if (x3 <= y3 && out[x3][y3]) t3 = dfs(x3, y3);
|
||||
tmp = min(tmp, max(t1,max(t2, t3)));
|
||||
}
|
||||
return f[x][y] = tmp + 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int k;
|
||||
scanf("%d", &T);
|
||||
for (int t=1; t<=T; t++)
|
||||
{
|
||||
memset(le, -1, sizeof(le));
|
||||
memset(f, -1, sizeof(f));
|
||||
memset(out, 0, sizeof(out));
|
||||
scanf("%d", &n);
|
||||
for (int i=1; i<=2*n; i++)
|
||||
{
|
||||
scanf("%d", &k);
|
||||
if (le[k] == -1) le[k] = i;
|
||||
else ri[k] = i;
|
||||
}
|
||||
for (int i=1; i<=2*n; i++)
|
||||
for (int j=i; j<=2*n; j++)
|
||||
for (int p=1; p<=n; p++)
|
||||
if (ri[p] <= j && ri[p] >= i) out[i][j]++;
|
||||
printf("Case #%d: %d\n", t, dfs(2, 2*n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=20;
|
||||
LL w[N];
|
||||
LL ans,n;
|
||||
LL get(LL x)
|
||||
{
|
||||
return x==0? 0:get(x-(x&-x))+1;
|
||||
}
|
||||
void dfs(LL beg,LL num,LL sym)
|
||||
{
|
||||
ans+=((LL)1<<get(num))*sym;
|
||||
for(LL i=beg+1;i<=n;i++)
|
||||
dfs(i,num&w[i],-2*sym);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL k=1,t,i;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>n;
|
||||
for(i=1;i<=n;i++)
|
||||
cin>>w[i];
|
||||
ans=0;
|
||||
for(i=1;i<=n;i++)
|
||||
dfs(i,w[i],1);
|
||||
cout<<"Case #"<<k++<<": "<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,179 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=1000005;
|
||||
int p[N];
|
||||
bool prime[N];
|
||||
int num,cnt;
|
||||
LL k,m,newx,g;
|
||||
LL a[65],b[65];
|
||||
void isprime()
|
||||
{
|
||||
num=0;
|
||||
int i,j;
|
||||
memset(prime,true,sizeof(prime));
|
||||
for(i=2;i<N;i++)
|
||||
{
|
||||
if(prime[i])
|
||||
{
|
||||
p[num++]=i;
|
||||
for(j=i+i;j<N;j+=i)
|
||||
{
|
||||
prime[j]=false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
LL multi(LL a,LL b,LL m)
|
||||
{
|
||||
LL ans=0;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
ans=(ans+a)%m;
|
||||
b--;
|
||||
}
|
||||
b>>=1;
|
||||
a=(a+a)%m;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL quick_mod(LL a,LL b,LL m)
|
||||
{
|
||||
LL ans=1;
|
||||
a%=m;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
ans=multi(ans,a,m);
|
||||
b--;
|
||||
}
|
||||
b>>=1;
|
||||
a=multi(a,a,m);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void factor(LL n)
|
||||
{
|
||||
cnt=0;
|
||||
for(int i=0;(LL)p[i]*p[i]<=n;i++)
|
||||
{
|
||||
if(n%p[i]==0)
|
||||
{
|
||||
a[cnt]=p[i];
|
||||
int c=0;
|
||||
while(n%p[i]==0)
|
||||
{
|
||||
c++;
|
||||
n/=p[i];
|
||||
}
|
||||
b[cnt++]=c;
|
||||
}
|
||||
}
|
||||
if(n>1)
|
||||
{
|
||||
a[cnt]=n;
|
||||
b[cnt++]=1;
|
||||
}
|
||||
}
|
||||
LL extend_Euclid(LL a,LL b,LL &x,LL &y)
|
||||
{
|
||||
if(b==0)
|
||||
{
|
||||
x=1;
|
||||
y=0;
|
||||
return a;
|
||||
}
|
||||
LL gd=extend_Euclid(b,a%b,x,y);
|
||||
LL temp=x;
|
||||
x=y;
|
||||
y=temp-(a/b)*y;
|
||||
return gd;
|
||||
}
|
||||
LL Inv(LL n,LL p)
|
||||
{
|
||||
return quick_mod(n,p-2,p);
|
||||
}
|
||||
bool dfs(int dept,LL t)
|
||||
{
|
||||
if(dept==cnt)
|
||||
{
|
||||
LL ans=quick_mod(g,t,m);
|
||||
if(ans==1&&t!=m-1) return false;
|
||||
return true;
|
||||
}
|
||||
LL tmp=1;
|
||||
for(int i=0;i<=b[dept];i++)
|
||||
{
|
||||
if(!dfs(dept+1,t*tmp)) return false;
|
||||
tmp*=a[dept];
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void find()
|
||||
{
|
||||
factor(m-1);
|
||||
for(g=2;;g++)
|
||||
if(dfs(0,1)) break;
|
||||
}
|
||||
LL log_x(LL a,LL b,LL p)
|
||||
{
|
||||
map<LL,int>x;
|
||||
LL z=(LL)ceil(sqrt(p*1.0));
|
||||
LL v=Inv(quick_mod(a,z,p),p);
|
||||
LL e=1;
|
||||
x[1]=0;
|
||||
for(int i=1;i<z;i++)
|
||||
{
|
||||
e=multi(e,a,p);
|
||||
if(!x.count(e))
|
||||
x[e]=i;
|
||||
}
|
||||
for(int i=0;i<z;i++)
|
||||
{
|
||||
if(x.count(b))
|
||||
return i*z+x[b];
|
||||
b=multi(b,v,p);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
LL sol[1005];
|
||||
void Solve(LL a,LL b,LL n)
|
||||
{
|
||||
LL d,x,y;
|
||||
d=extend_Euclid(a,n,x,y);
|
||||
if(b%d) puts("-1");
|
||||
else
|
||||
{
|
||||
n/=d;b/=d;
|
||||
sol[0]=(x*b%n+n)%n;
|
||||
for(int i=1;i<d;i++)
|
||||
sol[i]=sol[i-1]+n;
|
||||
for(int i=0;i<d;i++)
|
||||
sol[i]=quick_mod(g,sol[i],m);
|
||||
sort(sol,sol+d);
|
||||
for(int i=0;i<d;i++)
|
||||
cout<<sol[i]<<endl;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t=1;
|
||||
isprime();
|
||||
while(cin>>k>>m>>newx)
|
||||
{
|
||||
find();
|
||||
LL t1=log_x(g,newx,m);
|
||||
LL t2=m-1;
|
||||
cout<<"case"<<t++<<":"<<endl;
|
||||
Solve(k,t1,t2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
const int maxN=255;
|
||||
const int maxn=550;
|
||||
const int inf=1<<25;
|
||||
const int s=0;
|
||||
int L , W , N , P;
|
||||
struct edge{
|
||||
int v,next,w;
|
||||
}edge[maxn*maxn];
|
||||
int head[maxn],cnt;//for sap
|
||||
void addedge(int u, int v, int w)
|
||||
{
|
||||
edge[cnt].v=v;
|
||||
edge[cnt].w=w;
|
||||
edge[cnt].next=head[u];
|
||||
head[u]=cnt++;
|
||||
edge[cnt].v=u;
|
||||
edge[cnt].w=0;
|
||||
edge[cnt].next=head[v];
|
||||
head[v]=cnt++;
|
||||
}
|
||||
int sap(int t)
|
||||
{
|
||||
int pre[maxn],cur[maxn],dis[maxn],gap[maxn];
|
||||
int flow=0 , aug=inf ,u;
|
||||
bool flag;
|
||||
for (int i=0 ; i<=t ; ++i)
|
||||
{
|
||||
cur[i]=head[i];
|
||||
gap[i]=dis[i]=0;
|
||||
}
|
||||
gap[s]=t+1;
|
||||
u=pre[s]=s;
|
||||
while (dis[s]<=t)
|
||||
{
|
||||
flag=0 ;
|
||||
for (int &j=cur[u] ; ~j ; j=edge[j].next)
|
||||
{
|
||||
int v=edge[j].v;
|
||||
if (edge[j].w>0 && dis[u]==dis[v]+1)
|
||||
{
|
||||
flag=1;
|
||||
if(edge[j].w<aug)aug=edge[j].w;
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if (u==t)
|
||||
{
|
||||
flow+=aug;
|
||||
while (u!=s)
|
||||
{
|
||||
u=pre[u];
|
||||
edge[cur[u]].w-=aug;
|
||||
edge[cur[u]^1].w+=aug;
|
||||
}
|
||||
aug=inf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (flag)continue ;
|
||||
int mindis=t+1;
|
||||
for (int j=head[u]; ~j ; j=edge[j].next)
|
||||
{
|
||||
int v=edge[j].v;
|
||||
if (edge[j].w>0 && dis[v]<mindis)
|
||||
{
|
||||
mindis=dis[v];
|
||||
cur[u]=j;
|
||||
}
|
||||
}
|
||||
if(--gap[dis[u]]==0)break;
|
||||
gap[dis[u]=mindis+1]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return flow;
|
||||
}
|
||||
int x[maxN],y[maxN],r[maxN],p[maxN];//for build graph
|
||||
bool intersect (int a,int b)
|
||||
{
|
||||
int dis=(x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]);
|
||||
if(dis<=((r[a]+r[b])*(r[a]+r[b])))return true ;
|
||||
else return false ;
|
||||
}
|
||||
void build_graph()
|
||||
{
|
||||
int n=2*N;
|
||||
for (int i=1 ; i<=N ; ++i)
|
||||
{
|
||||
addedge (i,i+N,p[i]);
|
||||
if(y[i]<=r[i])addedge(0,i,inf);
|
||||
if(y[i]+r[i]>=W)addedge(i+N,n+1,inf);
|
||||
for (int j=i+1 ; j<=N ; ++j)//
|
||||
if(intersect(i,j))addedge(i+N,j,inf),addedge(j+N,i,inf);
|
||||
}
|
||||
}
|
||||
void init ()
|
||||
{
|
||||
memset (head , -1 , sizeof(head));
|
||||
cnt=0;
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
while (~scanf("%d%d%d%d",&L,&W,&N,&P))
|
||||
{
|
||||
init();
|
||||
for (int i=1 ; i<=N ; ++i)
|
||||
scanf("%d %d %d %d",x+i,y+i,r+i,p+i);
|
||||
build_graph();
|
||||
int ans=P-sap(2*N+1);
|
||||
if(ans<0)printf("Our hero has been killed\n");
|
||||
else printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <time.h>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
const double pi=acos(-1.0);
|
||||
const int maxn=1005;
|
||||
double x[maxn], y[maxn];
|
||||
int n;
|
||||
double dis2 (double x1,double y1 ,double x2,double y2)
|
||||
{
|
||||
double tmp1=x1-x2,tmp2=y1-y2;
|
||||
tmp1*=tmp1;
|
||||
tmp2*=tmp2;
|
||||
return tmp1+tmp2;
|
||||
}
|
||||
double test(double xx, double yy)
|
||||
{
|
||||
double max = 0,tmp;
|
||||
for (int i=0;i<n;i++)
|
||||
if(max<(tmp=dis2(xx,yy,x[i],y[i])))max=tmp;
|
||||
return max;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double xx,yy;
|
||||
double delta,theta;
|
||||
double X,Y;
|
||||
double retx,rety,ans;
|
||||
while (~scanf("%lf%lf%d",&X,&Y,&n))
|
||||
{
|
||||
for (int i=0 ; i<n ; i++)
|
||||
scanf("%lf%lf",x+i,y+i);
|
||||
double ans=1000000000.0;
|
||||
for (int i=0 ; i<10 ; ++i)
|
||||
{
|
||||
xx=((double)(rand()%1001)/1000.0)*X;
|
||||
yy=((double)(rand()%1001)/1000.0)*Y;
|
||||
double dis=test(xx,yy);
|
||||
for (delta=X ; delta>0.001 ; delta*=0.9)
|
||||
{
|
||||
for (theta=0 ; theta<=2*pi ; theta+=(pi/25.0))
|
||||
{
|
||||
double tx=xx+delta*cos(theta);
|
||||
double ty=yy+delta*sin(theta);
|
||||
double tdis=test(tx,ty);
|
||||
if(tdis<dis)
|
||||
{
|
||||
xx=tx;
|
||||
yy=ty;
|
||||
dis=tdis;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(dis<ans)
|
||||
{
|
||||
retx=xx;
|
||||
rety=yy;
|
||||
ans=dis;
|
||||
}
|
||||
}
|
||||
printf("(%.1lf,%.1lf).\n%.1lf\n",retx,rety,sqrt(ans));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cctype>
|
||||
using namespace std;
|
||||
const int maxn=1001;
|
||||
const int maxs=101;
|
||||
int dp[maxs][maxn];
|
||||
int data[maxn];
|
||||
int min(int a,int b){
|
||||
return a<b?a:b;
|
||||
}
|
||||
int main(){
|
||||
int n,s,la,lb;
|
||||
while(scanf("%d",&n)&&n){
|
||||
scanf("%d%d%d",&lb,&la,&s);
|
||||
memset(dp,0,sizeof(dp));
|
||||
int i,j,k;
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%d",&data[i]);
|
||||
dp[0][i]=data[i];
|
||||
dp[0][i]+=dp[0][i-1];
|
||||
}
|
||||
for(i=1;i<=s;i++){
|
||||
for(j=1;j<=n;j++){
|
||||
dp[i][j]=dp[i][j-1]+data[j];
|
||||
for(k=la;k<=lb && k<=j;k++){
|
||||
dp[i][j]=min(dp[i][j],dp[i-1][j-k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=1<<30;
|
||||
for(i=0;i<=s;i++){
|
||||
ans=min(dp[s][n],ans);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
#define PR 1e-8
|
||||
#define N 50015
|
||||
struct TPoint
|
||||
{
|
||||
double x,y;
|
||||
TPoint(){}
|
||||
TPoint(double _x,double _y):x(_x),y(_y){}
|
||||
TPoint operator-(const TPoint p) {return TPoint(x-p.x,y-p.y);}
|
||||
}ply[N];
|
||||
int n;
|
||||
double MAX(double a,double b) {return a>b?a:b;}
|
||||
double dist(TPoint a,TPoint b)
|
||||
{
|
||||
TPoint c(b-a);
|
||||
return sqrt(c.x*c.x+c.y*c.y);
|
||||
}
|
||||
double cross(TPoint a,TPoint b,TPoint c)
|
||||
{
|
||||
TPoint s(b-a),t(c-a);
|
||||
return s.x*t.y-s.y*t.x;
|
||||
}
|
||||
int dblcmp(double a)
|
||||
{
|
||||
if(fabs(a)<PR) return 0;
|
||||
return a>0?1:-1;
|
||||
}
|
||||
bool cmpx(TPoint a,TPoint b)
|
||||
{
|
||||
if(fabs(a.x-b.x)<PR) return a.y<b.y;
|
||||
return a.x<b.x;
|
||||
}
|
||||
bool cmp(TPoint a,TPoint b)
|
||||
{
|
||||
int d1=dblcmp(cross(ply[0],a,b));
|
||||
return d1>0||(d1==0&&dist(ply[0],a)<dist(ply[0],b));
|
||||
}
|
||||
double diss(TPoint a,TPoint b)
|
||||
{
|
||||
return dist(a,b)*dist(a,b);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
int i,top=2,j,p,q,r;
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%lf%lf",&ply[i].x,&ply[i].y);
|
||||
sort(ply,ply+n,cmpx);
|
||||
sort(ply+1,ply+n,cmp);
|
||||
for(i=2;i<n;i++)
|
||||
{
|
||||
while(top>1&&(dblcmp(cross(ply[top-2],ply[i],ply[top-1])))>=0) top--;
|
||||
ply[top++]=ply[i];
|
||||
}
|
||||
double max1=-1e20,tmp;
|
||||
n=top; ply[n]=ply[0]; ply[n+1]=ply[1]; ply[n+2]=ply[2];
|
||||
p=0; q=1; r=2;
|
||||
while(1)
|
||||
{
|
||||
int pp=p,qq=q,rr=r;
|
||||
while(cross(ply[p],ply[q],ply[r+1])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
|
||||
r=(r+1)%n;
|
||||
max1=MAX(max1,fabs(tmp)*0.5);
|
||||
while(cross(ply[p],ply[q+1],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
|
||||
q=(q+1)%n;
|
||||
max1=MAX(max1,fabs(tmp)*0.5);
|
||||
while(cross(ply[p+1],ply[q],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
|
||||
p=(p+1)%n;
|
||||
max1=MAX(max1,fabs(tmp)*0.5);
|
||||
if(pp==p&&qq==q&&rr==r) r=(r+1)%n;
|
||||
if(r==0) break;
|
||||
}
|
||||
if(n<3) max1=0;
|
||||
printf("%.2lf\n",max1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define maxn 105
|
||||
int g[maxn];
|
||||
int x[maxn];
|
||||
int n,m;
|
||||
int inf=100*100;
|
||||
int all;
|
||||
int Get(int n)
|
||||
{
|
||||
n=(n&0x55555555)+((n>>1)&0x55555555);
|
||||
n=(n&0x33333333)+((n>>2)&0x33333333);
|
||||
n=(n&0x0f0f0f0f)+((n>>4)&0x0f0f0f0f);
|
||||
n=(n&0x00ff00ff)+((n>>8)&0x00ff00ff);
|
||||
n=(n&0x0000ffff)+((n>>16)&0x0000ffff);
|
||||
return n;
|
||||
}
|
||||
void heng(int &x,int i)
|
||||
{
|
||||
x^=i;x^=i<<1;x^=i>>1;
|
||||
x=x&all;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j,k;
|
||||
while(scanf("%d%d", &n,&m) != EOF)
|
||||
{
|
||||
memset(g,0,sizeof(g));
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
int tmp;
|
||||
scanf("%d",&tmp);
|
||||
g[i]=g[i]<<1|tmp;
|
||||
}
|
||||
}
|
||||
all=(1<<m)-1;
|
||||
int ans=inf;
|
||||
for(i=0;i<(1<<m);i++)
|
||||
{
|
||||
for(k=0;k<n;k++)x[k]=g[k];
|
||||
int t=Get(i);
|
||||
heng(x[0],i);
|
||||
x[1]^=i;
|
||||
for(j=1;j<n;j++)
|
||||
{
|
||||
int k=x[j-1]^all;
|
||||
heng(x[j],k);
|
||||
x[j+1]^=k;
|
||||
t+=Get(k);
|
||||
}
|
||||
if(t<ans&&x[n-1]==all)ans=t;
|
||||
}
|
||||
if(ans==inf)printf("no solution\n");
|
||||
else printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
typedef long long ll;
|
||||
const ll mod=1000000007;
|
||||
ll mtrx[60][2][2];
|
||||
void pre_pro()
|
||||
{
|
||||
memset (mtrx , 0 , sizeof(mtrx));
|
||||
mtrx[0][0][0]=1;mtrx[0][0][1]=1;
|
||||
mtrx[0][1][0]=1;mtrx[0][1][1]=0;
|
||||
for (int t=0 ; t<60 ; ++t)
|
||||
for (int i=0 ; i<2 ; ++i)
|
||||
for (int j=0 ; j<2 ; ++j)
|
||||
{
|
||||
for (int k=0 ; k<2 ; ++k)
|
||||
mtrx[t+1][i][j]+=mtrx[t][i][k]*mtrx[t][k][j];
|
||||
mtrx[t+1][i][j]%=mod;
|
||||
}
|
||||
}
|
||||
ll fib (ll a)
|
||||
{
|
||||
a--;
|
||||
ll mat[2][2]={1,0,0,1};
|
||||
ll tmp[2][2];
|
||||
for (int p=0 ; a ; a>>=1 , ++p)
|
||||
{
|
||||
if(!(a&1))continue;
|
||||
tmp[0][0]=mat[0][0];tmp[0][1]=mat[0][1];
|
||||
tmp[1][0]=mat[1][0];tmp[1][1]=mat[1][1];
|
||||
memset (mat, 0 , sizeof(mat));
|
||||
for (int i=0 ; i<2 ; ++i)
|
||||
for (int j=0 ; j<2 ; ++j)
|
||||
{
|
||||
for (int k=0 ; k<2 ; ++k)
|
||||
mat[i][j]+=mtrx[p][i][k]*tmp[k][j];
|
||||
mat[i][j]%=mod;
|
||||
}
|
||||
}
|
||||
return mat[0][0];
|
||||
}
|
||||
ll sum(ll a)
|
||||
{
|
||||
if(a==0)return 0;
|
||||
else return fib(2*a)*fib(2*a+1)%mod;
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
pre_pro();
|
||||
int cas;
|
||||
scanf("%d",&cas);
|
||||
while (cas--)
|
||||
{
|
||||
ll l,r;
|
||||
scanf("%I64d%I64d",&l,&r);
|
||||
printf("%d\n",(sum(r)-sum(l-1)+mod)%mod);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#define N 64
|
||||
struct trie{
|
||||
int next[N];
|
||||
int tag;
|
||||
}data[3000000];
|
||||
int inp;
|
||||
int init(int a){
|
||||
memset(data[a].next,0,sizeof(data[a].next));
|
||||
data[a].tag=0;
|
||||
return a;
|
||||
}
|
||||
int tran(char a){
|
||||
if(a>='A'&&a<='Z') return a-'A';
|
||||
if(a>='a'&&a<='z') return a-'a'+26;
|
||||
return a-'0'+52;
|
||||
}
|
||||
void insert(char *a){
|
||||
int p=0;
|
||||
for(;*a;a++){
|
||||
int d=tran(*a);
|
||||
if(data[p].next[d]==0)data[p].next[d]=init(++inp);
|
||||
p=data[p].next[d];
|
||||
data[p].tag++;
|
||||
}
|
||||
}
|
||||
int query(char *a){
|
||||
int p=data[0].next[tran(*a)];
|
||||
for(a++;*a&&p;a++){
|
||||
int d=tran(*a);
|
||||
p=data[p].next[d];
|
||||
}
|
||||
return data[p].tag;
|
||||
}
|
||||
bool isok(double x,double y){
|
||||
return (fabs(x-y)/x)<0.11;
|
||||
}
|
||||
int getint(char *a){
|
||||
int ret=0;
|
||||
for(int i=0;i<8;i++)
|
||||
ret=ret*2+a[i];
|
||||
return ret;
|
||||
}
|
||||
char be[]="begin";
|
||||
char en[]="end";
|
||||
bool cmp(char *a,char *b,int len){
|
||||
for(int i=0;i<len;i++)
|
||||
if(a[i]!=b[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
int T,n,m,tf;
|
||||
double a,b;
|
||||
char str[100],ss[10];
|
||||
int main(void){
|
||||
while(scanf("%d%d",&T,&m)+1){
|
||||
inp=0;init(0);
|
||||
tf=0;
|
||||
for(int i=0;i<T;i++){
|
||||
scanf("%s",str);
|
||||
insert(str);
|
||||
}
|
||||
for(;m;m--){
|
||||
tf=0;
|
||||
double temp;
|
||||
scanf("%d",&n);
|
||||
scanf("%lf%lf",&a,&b);
|
||||
if(!(a<b&&isok(2*a,b))){
|
||||
tf=1;
|
||||
}
|
||||
ss[0]=0,ss[1]=1;
|
||||
for(int i=2;i<8;i++){
|
||||
scanf("%lf",&temp);
|
||||
if(isok(temp,a))
|
||||
ss[i]=0;
|
||||
else
|
||||
ss[i]=1;
|
||||
}
|
||||
str[0]=getint(ss);
|
||||
for(int i=1;i<n;i++){
|
||||
for(int j=0;j<8;j++){
|
||||
scanf("%lf",&temp);
|
||||
if(isok(temp,a)){
|
||||
ss[j]=0;
|
||||
}
|
||||
else{
|
||||
ss[j]=1;
|
||||
}
|
||||
}
|
||||
str[i]=getint(ss);
|
||||
}
|
||||
str[n]='\0';
|
||||
if(!cmp(be,str,5)||!cmp(en,str+n-3,3))
|
||||
tf=1;
|
||||
if(tf){
|
||||
printf("wrong barcode!\n");
|
||||
}
|
||||
else{
|
||||
str[n-3]='\0';
|
||||
printf("%d\n",query(str+5));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <deque>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <bitset>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <numeric>
|
||||
#include <utility>
|
||||
#include <sstream>
|
||||
#include <iomanip>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <cctype>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#define INF 2000000000
|
||||
#define MAXN 10005
|
||||
#define L(x) x<<1
|
||||
#define R(x) x<<1|1
|
||||
using namespace std;
|
||||
int n, m, q;
|
||||
int father[MAXN], num[MAXN];
|
||||
long long out[MAXN];
|
||||
struct node
|
||||
{
|
||||
int u, v, w;
|
||||
bool operator <(const node &a)const
|
||||
{
|
||||
return w < a.w;
|
||||
}
|
||||
}edge[MAXN * 10];
|
||||
struct wen
|
||||
{
|
||||
int l, id;
|
||||
bool operator <(const wen &a)const
|
||||
{
|
||||
return l < a.l;
|
||||
}
|
||||
}p[MAXN];
|
||||
void init()
|
||||
{
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
father[i] = i;
|
||||
num[i] = 1;
|
||||
}
|
||||
}
|
||||
int find(int x)
|
||||
{
|
||||
if(father[x] == x) return x;
|
||||
int t = find(father[x]);
|
||||
father[x] = t;
|
||||
return t;
|
||||
}
|
||||
int join(int x, int y)
|
||||
{
|
||||
int fx = find(x);
|
||||
int fy = find(y);
|
||||
if(fx == fy) return 0;
|
||||
int t = num[fx] * num[fy];
|
||||
num[fx] += num[fy];
|
||||
num[fy] = 0;
|
||||
father[fy] = fx;
|
||||
return t;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d%d", &n, &m, &q) != EOF)
|
||||
{
|
||||
init();
|
||||
for(int i = 1; i <= m; i++)
|
||||
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
|
||||
sort(edge + 1, edge + m + 1);
|
||||
for(int i = 1; i <= q; i++)
|
||||
{
|
||||
scanf("%d", &p[i].l);
|
||||
p[i].id = i;
|
||||
}
|
||||
sort(p + 1, p + q + 1);
|
||||
int pos = 1;
|
||||
long long ans = 0;
|
||||
for(int i = 1; i <= q; i++)
|
||||
{
|
||||
while(pos <= m && edge[pos].w <= p[i].l)
|
||||
{
|
||||
ans += join(edge[pos].u, edge[pos].v);
|
||||
pos ++;
|
||||
}
|
||||
out[p[i].id] = ans;
|
||||
}
|
||||
for(int i = 1; i <= q; i++)
|
||||
printf("%I64d\n", out[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
#define maxn 1000010
|
||||
int phi[maxn];
|
||||
int prime[maxn],cnt;
|
||||
bool flag[maxn];
|
||||
int p[100],num;
|
||||
LL ans,l;
|
||||
void init()
|
||||
{
|
||||
cnt=0;
|
||||
memset(flag,0,sizeof(flag));
|
||||
for(int i=2;i<maxn;i++)
|
||||
if(!flag[i])
|
||||
{
|
||||
prime[cnt++]=i;
|
||||
for(int j=i+i;j<maxn;j+=i)
|
||||
flag[j]=1;
|
||||
}
|
||||
for(int i=0;i<maxn;i++) phi[i]=i;
|
||||
for(int i=2;i<maxn;i+=2) phi[i]>>=1;
|
||||
for(int i=3;i<maxn;i+=2)
|
||||
if(phi[i]==i)
|
||||
for(int j=i;j<maxn;j+=i)
|
||||
phi[j]=phi[j]-phi[j]/i;
|
||||
}
|
||||
void divide(int x)
|
||||
{
|
||||
num=0;
|
||||
for(int i=0;i<cnt&&prime[i]*prime[i]<=x;i++)
|
||||
if(x%prime[i]==0)
|
||||
{
|
||||
p[num++]=prime[i];
|
||||
while(x%prime[i]==0) x/=prime[i];
|
||||
}
|
||||
if(x>1) p[num++]=x;
|
||||
}
|
||||
void dfs(int id,int mul,int tot,int x)
|
||||
{
|
||||
if(id==num)
|
||||
{
|
||||
if(tot&1) ans=ans-x/mul;
|
||||
else ans=ans+x/mul;
|
||||
return ;
|
||||
}
|
||||
dfs(id+1,mul*p[id],tot+1,x);
|
||||
dfs(id+1,mul,tot,x);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int t;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%lld",&l);
|
||||
int temp=sqrt(l+0.0);
|
||||
ans=0;
|
||||
for(int i=1;i<=temp;i++)
|
||||
{
|
||||
int lim=sqrt(l-(LL)i*i+0.0);
|
||||
if(i&1)
|
||||
{
|
||||
divide(i);
|
||||
if(i<=lim) dfs(0,1,0,i>>1);
|
||||
else dfs(0,1,0,lim>>1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(i<=lim) ans+=phi[i];
|
||||
else
|
||||
{
|
||||
divide(i);
|
||||
dfs(0,1,0,lim);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%lld\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
double fly_pos(double vx,double vy,double h)
|
||||
{
|
||||
return vx*(vy+sqrt(vy*vy+19.6*h))/9.8;
|
||||
}
|
||||
double fly_h(double vy,double h,double t)
|
||||
{
|
||||
return h+vy*t-4.9*t*t;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double h,vx,vy,t,h0,l,v1,v2,v3;
|
||||
char bird[10];
|
||||
while(~scanf("%lf%s",&h,bird))
|
||||
{
|
||||
if(!strcmp("Red",bird))
|
||||
{
|
||||
scanf("%lf%lf",&vx,&vy);
|
||||
printf("%.3lf\n",fly_pos(vx,vy,h));
|
||||
}
|
||||
else if(!strcmp("Blue",bird))
|
||||
{
|
||||
scanf("%lf%lf%lf%lf%lf%lf",&vx,&vy,&t,&v1,&v2,&v3);
|
||||
if(fly_pos(vx,vy,h)<t*vx)
|
||||
{
|
||||
printf("%.3lf\n",fly_pos(vx,vy,h));
|
||||
continue;
|
||||
}
|
||||
h0=fly_h(vy,h,t);
|
||||
l=vx*t;
|
||||
vy=vy-9.8*t;
|
||||
printf("%.3lf %.3lf %.3lf\n",l+fly_pos(v1,vy,h0),l+fly_pos(v2,vy,h0),l+fly_pos(v3,vy,h0));
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%lf%lf%lf",&vx,&vy,&t);
|
||||
if(fly_pos(vx,vy,h)<t*vx)
|
||||
{
|
||||
printf("%.3lf\n",fly_pos(vx,vy,h));
|
||||
continue;
|
||||
}
|
||||
h0=fly_h(vy,h,t);
|
||||
l=vx*t;
|
||||
vy=vy-9.8*t;
|
||||
printf("%.3lf\n",l+fly_pos(2*vx,2*vy,h0));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int MOD=1000000007;
|
||||
const int MaxN=103;
|
||||
const int MaxM=203;
|
||||
int N,K,f[2][MaxN][MaxM],s[MaxN][MaxM];
|
||||
int solve()
|
||||
{
|
||||
int MaxK=2*K+1;
|
||||
for (int i=0; i<=K; ++i)
|
||||
for (int j=0; j<=MaxK; ++j) f[0][i][j]=s[i][j]=0;
|
||||
f[0][0][0]=1;
|
||||
s[0][0]=1;
|
||||
int cur=0,last;
|
||||
for (int i=1; i<=N; ++i)
|
||||
{
|
||||
last=cur;
|
||||
cur=1-cur;
|
||||
for (int j=0; j<=K; ++j)
|
||||
for (int k=0; k<=MaxK; ++k) f[cur][j][k]=0;
|
||||
f[cur][0][0]=1;
|
||||
for (int j=1; j<=K; ++j)
|
||||
{
|
||||
for (int k=j; k<MaxK-1; ++k)
|
||||
{
|
||||
f[cur][j][k]=f[cur][j-1][k-1]+f[last][j][k-j];
|
||||
f[cur][j][k]%=MOD;
|
||||
}
|
||||
for (int p=0; p<=j; ++p)
|
||||
{
|
||||
int cnt=MaxK-1-j;
|
||||
f[cur][j][MaxK-1]+=s[p][cnt];
|
||||
f[cur][j][MaxK-1]%=MOD;
|
||||
cnt=MaxK-j;
|
||||
f[cur][j][MaxK]+=s[p][cnt];
|
||||
f[cur][j][MaxK]%=MOD;
|
||||
}
|
||||
}
|
||||
for (int j=0; j<=K; ++j)
|
||||
for (int k=MaxK; k>=0; --k) s[j][k]=f[cur][j][k];
|
||||
for (int j=0; j<=K; ++j)
|
||||
for (int k=MaxK-2; k>=0; --k)
|
||||
{
|
||||
s[j][k]+=s[j][k+2];
|
||||
s[j][k]%=MOD;
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for (int i=0; i<=K; ++i)
|
||||
for (int j=i+i; j<MaxK; j+=2)
|
||||
{
|
||||
ans+=f[cur][i][j];
|
||||
ans%=MOD;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int Testnum;
|
||||
scanf("%d",&Testnum);
|
||||
for (int Test=1; Test<=Testnum; ++Test)
|
||||
{
|
||||
scanf("%d %d",&N,&K);
|
||||
printf("Case #%d: %d\n",Test,solve());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include"cstdlib"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
#include"cmath"
|
||||
#include"queue"
|
||||
#include"algorithm"
|
||||
#include"iostream"
|
||||
using namespace std;
|
||||
__int64 dp[22][22][22];
|
||||
int num[22];
|
||||
__int64 dfs(int site,int a,int b,int f,int x,int y)
|
||||
{
|
||||
if(site==0)
|
||||
{
|
||||
if(a==x&&b==y) return 1;
|
||||
return 0;
|
||||
}
|
||||
if(!f&&dp[site][a][b]!=-1) return dp[site][a][b];
|
||||
int len=f?num[site]:9;
|
||||
__int64 ans=0;
|
||||
for(int i=0;i<=len;i++)
|
||||
{
|
||||
if(i==4) ans+=dfs(site-1,a+1,b,f&&i==len,x,y);
|
||||
else if(i==7) ans+=dfs(site-1,a,b+1,f&&i==len,x,y);
|
||||
else ans+=dfs(site-1,a,b,f&&i==len,x,y);
|
||||
}
|
||||
if(!f) dp[site][a][b]=ans;
|
||||
return ans;
|
||||
}
|
||||
__int64 solve(__int64 a,int x,int y)
|
||||
{
|
||||
int cnt=0;
|
||||
while(a)
|
||||
{
|
||||
num[++cnt]=a%10;
|
||||
a/=10;
|
||||
}
|
||||
return dfs(cnt,0,0,1,x,y);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,cas=1;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
__int64 p,q;
|
||||
int x,y;
|
||||
scanf("%I64d%I64d%d%d",&p,&q,&x,&y);
|
||||
memset(dp,-1,sizeof(dp));
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
printf("Case #%d:\n",cas++);
|
||||
while(n--)
|
||||
{
|
||||
__int64 k,s;
|
||||
__int64 ans=-1;
|
||||
s=solve(p,x,y);
|
||||
scanf("%I64d",&k);
|
||||
s+=k;
|
||||
__int64 l=p+1,r=q;
|
||||
while(l<=r)
|
||||
{
|
||||
__int64 mid=(l+r)/2;
|
||||
if(solve(mid,x,y)>=s)
|
||||
{
|
||||
ans=mid;
|
||||
r=mid-1;
|
||||
}
|
||||
else l=mid+1;
|
||||
}
|
||||
if(ans!=-1) printf("%I64d\n",ans);
|
||||
else puts("Nya!");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#define maxn 10000
|
||||
using namespace std;
|
||||
int flag[maxn],pim[maxn],tol;
|
||||
int p[1229][9973];
|
||||
int ni[1229][9973];
|
||||
int mp[10000];
|
||||
void init()
|
||||
{
|
||||
tol=0;
|
||||
for(int i=2; i<maxn; i++)
|
||||
{
|
||||
if(!flag[i]) pim[tol++]=i;
|
||||
for(int j=0; j<tol&&i*pim[j]<maxn; j++)
|
||||
{
|
||||
flag[i*pim[j]]=1;
|
||||
if(i%pim[j]==0) break;
|
||||
}
|
||||
}
|
||||
for(int i=0; i<tol; i++)
|
||||
{
|
||||
int k=pim[i];
|
||||
mp[k]=i;
|
||||
p[i][0]=1, p[i][1]=1;
|
||||
ni[i][0]=1,ni[i][1]=1;
|
||||
for(int j=2; j<k; j++)
|
||||
{
|
||||
p[i][j]=j*p[i][j-1]%pim[i];
|
||||
ni[i][j]=-k/j*ni[i][k%j]%k;
|
||||
if(ni[i][j]<0) ni[i][j]+=k;
|
||||
}
|
||||
}
|
||||
for(int i=0; i<tol; i++)
|
||||
{
|
||||
int k=pim[i];
|
||||
for(int j=1; j<k; j++)
|
||||
{
|
||||
ni[i][j]=ni[i][j]*ni[i][j-1]%k;
|
||||
}
|
||||
}
|
||||
}
|
||||
int cal(int n,int m,int v)
|
||||
{
|
||||
if(n<m) return 0;
|
||||
int x=mp[v];
|
||||
return p[x][n] * ni[x][m]%v * ni[x][n-m]%v;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,k,p,ca=0;
|
||||
init();
|
||||
while(scanf("%d %d %d",&n,&k,&p)==3)
|
||||
{
|
||||
if(k>n/2) k=n-k;
|
||||
int res=1,u_u=n-k;
|
||||
n++;
|
||||
while(n&&k)
|
||||
{
|
||||
res=res*cal(n%p,k%p,p)%p;
|
||||
if(res==0) break;
|
||||
n/=p;
|
||||
k/=p;
|
||||
}
|
||||
printf("Case #%d: %d\n",++ca,(res+u_u)%p);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define rep(i,n) for(int i=0;i<n;i++)
|
||||
#define mod 1000000009
|
||||
#define pb push_back
|
||||
vector <int> p[15];
|
||||
int st[15];
|
||||
int f[1<<16][20];
|
||||
int to[15][20][20];
|
||||
long long dp[15][25][25];
|
||||
int num[1<<16];
|
||||
int dx[]= {0,0,-1,1,1,1,-1,-1};
|
||||
int dy[]= {-1,1,0,0,1,-1,1,-1};
|
||||
int check(int x,int y)
|
||||
{
|
||||
if(x>=0 && x<4 && y>=0 && y<4)return 1;
|
||||
return 0;
|
||||
}
|
||||
int nxt(int t)
|
||||
{
|
||||
int ret=0;
|
||||
rep(i,17)
|
||||
{
|
||||
int x=i/4;
|
||||
int y=i%4;
|
||||
int cnt=0;
|
||||
for(int j=0; j<8; j++)
|
||||
{
|
||||
int nx = x+dx[j];
|
||||
int ny = y+dy[j];
|
||||
if(check(nx,ny))
|
||||
{
|
||||
int pos = nx*4+ny;
|
||||
if((1<<pos)&t)
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
if((1<<i)&t)
|
||||
{
|
||||
if(cnt==2||cnt==3)
|
||||
ret^=(1<<i);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(cnt==3)
|
||||
ret^=(1<<i);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int n = 1<<16;
|
||||
memset(num,0,sizeof(num));
|
||||
rep(i,n)rep(j,17)
|
||||
if(i&(1<<j))
|
||||
num[i]++;
|
||||
rep(i,n)f[i][0]=nxt(i);
|
||||
for(int i=1; i<=18; i++)
|
||||
for(int j=0; j<n; j++)
|
||||
f[j][i]=f[f[j][i-1]][i-1];
|
||||
}
|
||||
int getnxt(int s,int t)
|
||||
{
|
||||
for(int i=18; i>=0; i--)
|
||||
if((1<<i)<=t)
|
||||
{
|
||||
t-=(1<<i);
|
||||
s=f[s][i];
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int L,K,M,T,N,t;
|
||||
init();
|
||||
scanf("%d",&L);
|
||||
rep(cas,L)
|
||||
{
|
||||
scanf("%d%d%d%d",&K,&M,&T,&N);
|
||||
rep(i,K)p[i].clear();
|
||||
memset(st,0,sizeof(st));
|
||||
rep(k,K)rep(i,4)rep(j,4)
|
||||
{
|
||||
scanf("%d",&t);
|
||||
if(t)st[k]^=(1<<(i*4+j));
|
||||
}
|
||||
int n=1<<16;
|
||||
memset(to,0,sizeof(to));
|
||||
rep(k,K) // 10*2^16
|
||||
rep(i,n)
|
||||
if((st[k]&i) == st[k])
|
||||
{
|
||||
int j=i^st[k];
|
||||
int cnt1=num[j];
|
||||
int _nxt=getnxt(i,T);
|
||||
int cnt2=num[_nxt];
|
||||
to[k][cnt1][cnt2]++;
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[0][0][0]=1;
|
||||
for(int k=0; k<K; k++)
|
||||
{
|
||||
for(int i=0; i<=M; i++)
|
||||
{
|
||||
for(int j=0; j<=N; j++)
|
||||
{
|
||||
if(dp[k][i][j]==0)continue;
|
||||
for(int p=0; p<=16; p++)
|
||||
{
|
||||
for(int q=0; q<=16; q++)
|
||||
{
|
||||
if(to[k][p][q]==0)continue;
|
||||
if(i+p<=M && j+q<=N)
|
||||
dp[k+1][i+p][j+q]=(dp[k+1][i+p][j+q]+dp[k][i][j]*to[k][p][q])%mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
long long ret=0;
|
||||
for(int i=0; i<=M; i++)
|
||||
ret=(ret+dp[K][i][N])%mod;
|
||||
printf("Case #%d: %I64d\n",cas+1,ret);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
int a[10005], b[10005];
|
||||
int res, pre, as[10005];
|
||||
bool cmp(int x, int y)
|
||||
{
|
||||
return x>y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, m, an, bn, t=1, ca, i, end, lef, tmp;
|
||||
scanf("%d", &ca);
|
||||
while(ca-->0)
|
||||
{
|
||||
scanf("%d%d%d%d", &n, &m, &an, &bn);
|
||||
for(i=0; i<an; i++)
|
||||
scanf("%d", &a[i]);
|
||||
for(i=0; i<bn; i++)
|
||||
scanf("%d", &b[i]);
|
||||
sort(a, a+an, cmp);
|
||||
sort(b, b+bn, cmp);
|
||||
memset(as, 0, sizeof(as));
|
||||
for(i=1; i<=an; i++)as[i]=as[i-1]+a[i-1];
|
||||
end=n*m/3;
|
||||
if(((n==2)&&(m%3==2))||((m==2)&&(n%3==2)))end--;
|
||||
end=min(end, bn);
|
||||
res=as[min(n*m/2, an)];
|
||||
pre=0;
|
||||
for(i=1; i<=end; i++)
|
||||
{
|
||||
pre+=b[i-1];
|
||||
lef=min((n*m-3*i)/2, an);
|
||||
tmp=pre+as[lef];
|
||||
if(tmp>res)res=tmp;
|
||||
}
|
||||
printf("Case #%d: %d\n", t++, res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define sz 200
|
||||
#define inf 0x7fffffff
|
||||
int g[sz][sz];
|
||||
int s[sz],t[sz],v[sz];
|
||||
struct node{
|
||||
int s, t, v, len, nxt;
|
||||
} e[sz * 40 + 20];
|
||||
int hd[sz], cnt, pre[sz] , pos[sz], dis[sz], vis[sz];
|
||||
int sum ;
|
||||
void insert(int s, int t, int v, int len){
|
||||
e[cnt].s = s;e[cnt].t = t;e[cnt].v = v;e[cnt].len = len;
|
||||
e[cnt].nxt = hd[s];hd[s] = cnt++;
|
||||
e[cnt].s = t;e[cnt].t = s;e[cnt].v = 0;e[cnt].len = -len;
|
||||
e[cnt].nxt = hd[t];hd[t] = cnt++;
|
||||
}
|
||||
bool spfa(int s, int t, int n){
|
||||
for(int i = 0; i < n; i++){
|
||||
dis[i]=inf;
|
||||
vis[i]=0;
|
||||
pre[i]=-1;
|
||||
}
|
||||
queue<int>q;
|
||||
while(!q.empty())q.pop();
|
||||
q.push(s);
|
||||
pre[s] = s;
|
||||
dis[s] = 0;
|
||||
while( !q.empty() ){
|
||||
int u = q.front();
|
||||
q.pop();
|
||||
vis[u] = 0;
|
||||
for(int i = hd[u]; i!=-1; i=e[i].nxt){
|
||||
int v = e[i].t;
|
||||
if (e[i].v > 0 && dis[u] + e[i].len < dis[v]){
|
||||
dis[v] = dis[u] + e[i].len;
|
||||
pre[v] = u;
|
||||
pos[v] = i;
|
||||
if (!vis[v]){
|
||||
vis[v] = 1;
|
||||
q.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return pre[t] != -1 && dis[t] < inf;
|
||||
}
|
||||
int mcf(int s, int t, int n){
|
||||
int fw = 0, ct = 0;
|
||||
while(spfa(s,t,n)){
|
||||
int v = inf;
|
||||
for(int i = t; i != s; i = pre[i])
|
||||
v = min(v, e[pos[i]].v);
|
||||
fw += v;
|
||||
ct += dis[t] * v;
|
||||
for(int i = t; i != s; i = pre[i]){
|
||||
e[pos[i]].v -= v;
|
||||
e[pos[i] ^ 1].v += v;
|
||||
}
|
||||
}
|
||||
if(fw != sum)return -1;
|
||||
return ct;
|
||||
}
|
||||
struct node1{
|
||||
int s,t,v,nxt;
|
||||
}ne[sz*10];
|
||||
int nhd[sz],ncnt;
|
||||
void insert1(int s ,int t,int v){
|
||||
ne[ncnt].s=s;
|
||||
ne[ncnt].t=t;
|
||||
ne[ncnt].v=v;
|
||||
ne[ncnt].nxt = nhd[s];
|
||||
nhd[s]=ncnt++;
|
||||
}
|
||||
int main(){
|
||||
int TT;
|
||||
scanf("%d",&TT);
|
||||
for(int cas=1;cas<=TT;cas++){
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
memset(pre,-1,sizeof(pre));
|
||||
int S=0,T=n+1;
|
||||
memset(hd,-1,sizeof(hd));
|
||||
cnt = 0;
|
||||
memset(g,-1,sizeof(g));
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(nhd,-1,sizeof(nhd));
|
||||
ncnt=0;
|
||||
for(int i=1;i<n;i++){
|
||||
scanf("%d%d%d",&s[i],&t[i],&v[i]);
|
||||
g[s[i]][t[i]]=i;
|
||||
pre[s[i]] = t[i];
|
||||
insert1(t[i],s[i],v[i]);
|
||||
}
|
||||
s[n]=1;
|
||||
t[n]=n+1;
|
||||
v[n]=0;
|
||||
insert1(n+1,1,0);
|
||||
g[1][1+n]=n+1;
|
||||
pre[1]=n+1;
|
||||
sum=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
int vv = v[i];
|
||||
for(int j=nhd[s[i]];j!=-1;j=ne[j].nxt){
|
||||
vv -= ne[j].v;
|
||||
insert(i,g[ne[j].t][s[i]],inf,0);
|
||||
}
|
||||
if(vv>0){
|
||||
sum+=vv;
|
||||
insert(S,i,vv,0);
|
||||
}
|
||||
if(vv<0){
|
||||
insert(i,T,-vv,0);
|
||||
}
|
||||
}
|
||||
int m;
|
||||
cin>>m;
|
||||
int ss,tt,li,ci;
|
||||
for(int i=0;i<m;i++){
|
||||
scanf("%d%d%d%d",&ss,&tt,&li,&ci);
|
||||
insert(g[ss][pre[ss]],g[tt][pre[tt]],li,ci);
|
||||
}
|
||||
printf("Case #%d: ",cas);
|
||||
cout<<mcf(S,T,T+1)<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 200100
|
||||
int dp[MAXN][20];
|
||||
char r[MAXN];
|
||||
int sa[MAXN];
|
||||
int wa[MAXN],wb[MAXN],wv[MAXN],ws[MAXN];
|
||||
int height[MAXN],rk[MAXN];
|
||||
int mm[MAXN];
|
||||
int cas;
|
||||
inline bool cmp(int *r,int a,int b,int len){
|
||||
return r[a]==r[b]&&r[a+len]==r[b+len];
|
||||
}
|
||||
void SA(int n,int m){
|
||||
int i,j,p,*x=wa,*y=wb,*t;
|
||||
for(i=0;i<m;i++)
|
||||
ws[i]=0;
|
||||
for(i=0;i<n;i++)
|
||||
ws[x[i]=r[i]]++;
|
||||
for(i=1;i<m;i++)
|
||||
ws[i]+=ws[i-1];
|
||||
for(i=n-1;i>=0;i--)
|
||||
sa[--ws[x[i]]]=i;
|
||||
for(j=p=1;p<n;j<<=1,m=p){
|
||||
for(p=0,i=n-j;i<n;i++)
|
||||
y[p++]=i;
|
||||
for(i=0;i<n;i++){
|
||||
if(sa[i]>=j)
|
||||
y[p++]=sa[i]-j;
|
||||
}
|
||||
for(i=0;i<m;i++)
|
||||
ws[i]=0;
|
||||
for(i=0;i<n;i++)
|
||||
ws[wv[i]=x[y[i]]]++;
|
||||
for(i=1;i<m;i++)
|
||||
ws[i]+=ws[i-1];
|
||||
for(i=n-1;i>=0;i--)
|
||||
sa[--ws[wv[i]]]=y[i];
|
||||
for(t=x,x=y,y=t,x[sa[0]]=0,p=i=1;i<n;i++)
|
||||
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
|
||||
}
|
||||
}
|
||||
void Height(int n){
|
||||
int i,j,k=0;
|
||||
for(i=0;i<=n;i++)
|
||||
rk[sa[i]]=i;
|
||||
for(i=0;i<n;height[rk[i++]]=k)
|
||||
for(k?k--:0,j=sa[rk[i]-1];r[i+k]==r[j+k];k++);
|
||||
}
|
||||
int init(){
|
||||
int i,j,len;
|
||||
memset(height,0,sizeof(height));
|
||||
len=strlen(r);
|
||||
r[len]='$';
|
||||
for(j=0;j<len;j++)
|
||||
r[j+len+1]=r[len-1-j];
|
||||
r[j+len+1]='\0';
|
||||
return len*2+1;
|
||||
}
|
||||
void st(int n){
|
||||
int i,j,p,q;
|
||||
for(i=1;i<=n;i++)
|
||||
dp[i][0]=i;
|
||||
for(j=1;j<=mm[n];j++)
|
||||
for(i=1;i+(1<<j)-1<=n;i++){
|
||||
p=height[dp[i][j-1]];
|
||||
q=height[dp[i+(1<<(j-1))][j-1]];
|
||||
if(p>q)
|
||||
dp[i][j]=dp[i+(1<<(j-1))][j-1];
|
||||
else
|
||||
dp[i][j]=dp[i][j-1];
|
||||
}
|
||||
}
|
||||
int RMQ_MIN(int i,int j){
|
||||
int tem;
|
||||
if(i>j){
|
||||
tem=i;
|
||||
i=j;
|
||||
j=tem;
|
||||
}
|
||||
i++;
|
||||
int k=mm[(j-i+1)];
|
||||
return min(height[dp[i][k]],height[dp[j-(1<<k)+1][k]]);
|
||||
}
|
||||
void solve(int n){
|
||||
int i,j,ans=0,pre1=0,pre2=0;
|
||||
st(n);
|
||||
for(i=2;i<=n;i++){
|
||||
pre1=min(pre1,height[i]);
|
||||
j=RMQ_MIN(i,rk[n-1-sa[i]]);
|
||||
if(j>pre1){
|
||||
ans+=j-pre1;
|
||||
pre1=j;
|
||||
}
|
||||
pre2=min(pre2,height[i]);
|
||||
j=RMQ_MIN(i,rk[n-sa[i]]);
|
||||
if(j>pre2){
|
||||
ans+=j-pre2;
|
||||
pre2=j;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d\n",cas,ans);
|
||||
}
|
||||
int main(){
|
||||
int i,j,n,t,T;
|
||||
mm[0]=-1;
|
||||
for(i=1;i<MAXN;i++)
|
||||
mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
|
||||
scanf("%d",&T);
|
||||
cas=0;
|
||||
for(t=1;t<=T;t++){
|
||||
scanf("%s",r);
|
||||
n=init();
|
||||
SA(n+1,130);
|
||||
Height(n);
|
||||
cas++;
|
||||
solve(n);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#define MAXN 10010
|
||||
typedef long long LL;
|
||||
using namespace std;
|
||||
int n;
|
||||
LL a[MAXN];
|
||||
void Gauss() {
|
||||
int i, j, k, t;
|
||||
k = 0;
|
||||
for (i = 60; i >= 0; i--) {
|
||||
for (j = k; j < n; j++) {
|
||||
if ((a[j] >> i) & 1)
|
||||
break;
|
||||
}
|
||||
if (j < n) {
|
||||
swap(a[j], a[k]);
|
||||
for (t = 0; t < n; t++) {
|
||||
if (t != k && ((a[t] >> i) & 1))
|
||||
a[t] ^= a[k];
|
||||
}
|
||||
k++;
|
||||
}
|
||||
}
|
||||
sort(a, a + n);
|
||||
n = unique(a, a + n) - a;
|
||||
}
|
||||
LL Cal(int k) {
|
||||
LL ans;
|
||||
int i;
|
||||
ans = i = 0;
|
||||
if (a[0] == 0) {
|
||||
if (k == 1)
|
||||
return 0;
|
||||
k--;
|
||||
i++;
|
||||
}
|
||||
for (; i < n && k; k >>= 1, i++) {
|
||||
if (k & 1)
|
||||
ans ^= a[i];
|
||||
}
|
||||
if (i == n && k)
|
||||
return -1;
|
||||
return ans;
|
||||
}
|
||||
int main() {
|
||||
int c, ca = 1;
|
||||
int i, q;
|
||||
LL k;
|
||||
scanf("%d", &c);
|
||||
while (c--) {
|
||||
scanf("%d", &n);
|
||||
for (i = 0; i < n; i++)
|
||||
scanf("%I64d", &a[i]);
|
||||
Gauss();
|
||||
scanf("%d", &q);
|
||||
printf("Case #%d:\n", ca++);
|
||||
while (q--) {
|
||||
scanf("%I64d", &k);
|
||||
printf("%I64d\n", Cal(k));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
using namespace std;
|
||||
#define LL(x) (x<<1)
|
||||
#define RR(x) (x<<1|1)
|
||||
#define MID(a,b) (a+((b-a)>>1))
|
||||
#define INF (1<<30)
|
||||
const int N=50005;
|
||||
int n,q,ed[N];
|
||||
int st_len,ed_len;
|
||||
struct Segtree
|
||||
{
|
||||
set<int> T[N];
|
||||
int st[N*4],len[N*4];
|
||||
void PushUp(int ind)
|
||||
{
|
||||
if(st[LL(ind)]<st[RR(ind)])
|
||||
{
|
||||
st[ind]=st[LL(ind)];
|
||||
len[ind]=len[LL(ind)];
|
||||
}
|
||||
else
|
||||
{
|
||||
st[ind]=st[RR(ind)];
|
||||
len[ind]=len[RR(ind)];
|
||||
}
|
||||
}
|
||||
void build(int lft,int rht,int ind)
|
||||
{
|
||||
st[ind]=INF;
|
||||
if(lft==rht) T[lft].clear();
|
||||
else
|
||||
{
|
||||
int mid=MID(lft,rht);
|
||||
build(lft,mid,LL(ind));
|
||||
build(mid+1,rht,RR(ind));
|
||||
}
|
||||
}
|
||||
void updata(int pos,int ist,bool add,int ind,int lft,int rht)
|
||||
{
|
||||
if(lft==rht)
|
||||
{
|
||||
if(add) T[lft].insert(ist);
|
||||
else T[lft].erase(ist);
|
||||
if(T[lft].size()==0) st[ind]=INF;
|
||||
else
|
||||
{
|
||||
len[ind]=lft; st[ind]=*(T[lft].begin());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int mid=MID(lft,rht);
|
||||
if(pos<=mid) updata(pos,ist,add,LL(ind),lft,mid);
|
||||
else updata(pos,ist,add,RR(ind),mid+1,rht);
|
||||
PushUp(ind);
|
||||
}
|
||||
}
|
||||
pair<int,int> query(int ist,int ied,int ind,int lft,int rht)
|
||||
{
|
||||
if(ist<=lft&&rht<=ied) return make_pair(st[ind],len[ind]);
|
||||
else
|
||||
{
|
||||
int mid=MID(lft,rht);
|
||||
pair<int,int> tmp1,tmp2; tmp1.first=INF,tmp2.first=INF;
|
||||
if(ist<=mid) tmp1=query(ist,ied,LL(ind),lft,mid);
|
||||
if(ied> mid) tmp2=query(ist,ied,RR(ind),mid+1,rht);
|
||||
if(tmp1.first<tmp2.first) return tmp1;
|
||||
else return tmp2;
|
||||
}
|
||||
}
|
||||
}seg;
|
||||
struct BIT
|
||||
{
|
||||
int T[N],sum;
|
||||
void init(){memset(T,0,sizeof(T));sum=0;}
|
||||
int lowbit(int x){return x&-x;}
|
||||
void insert(int x,int add)
|
||||
{
|
||||
sum+=add;
|
||||
while(x<N)
|
||||
{
|
||||
T[x]+=add; x+=lowbit(x);
|
||||
}
|
||||
}
|
||||
int query(int k)
|
||||
{
|
||||
int ind=0;
|
||||
for(int i=20;i>=0;i--)
|
||||
{
|
||||
ind^=(1<<i);
|
||||
if(ind<N&&k>T[ind]) k-=T[ind];
|
||||
else ind^=(1<<i);
|
||||
}
|
||||
return ind+1;
|
||||
}
|
||||
int getsum()
|
||||
{
|
||||
return sum;
|
||||
}
|
||||
}bit;
|
||||
int calu(int st,int len,int m,int a,int b)
|
||||
{
|
||||
int ed=st+len-1;
|
||||
return max(ed-m-b+1,st);
|
||||
}
|
||||
bool judge(int st1,int st2,int &ilen,int &ist)
|
||||
{
|
||||
ist=st1;
|
||||
if(st1>st2) return false;
|
||||
ilen=st2-st1+1;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,t_cnt=0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&q);
|
||||
seg.build(1,n,1); bit.init();
|
||||
st_len=n,ed_len=n;
|
||||
printf("Case #%d:\n",++t_cnt);
|
||||
while(q--)
|
||||
{
|
||||
char cmd[5]; scanf("%s",cmd);
|
||||
if(cmd[0]=='A')
|
||||
{
|
||||
int m,a,b; scanf("%d%d%d",&m,&a,&b);
|
||||
if(st_len>=m)
|
||||
{
|
||||
if(st_len==n)
|
||||
{
|
||||
ed[1]=m; bit.insert(1,1); st_len=0; ed_len-=m;
|
||||
printf("%d\n",1);
|
||||
}
|
||||
else
|
||||
{
|
||||
int tmp=calu(1,st_len,m,a,b);
|
||||
ed[tmp]=tmp+m-1; bit.insert(tmp,1);
|
||||
printf("%d\n",tmp);
|
||||
int len,st;
|
||||
if(judge(ed[tmp]+1,st_len,len,st)) seg.updata(len,st,1,1,1,n);
|
||||
st_len=tmp-1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pair<int,int> res=seg.query(m,m+a+b,1,1,n);
|
||||
if(res.first!=INF)
|
||||
{
|
||||
seg.updata(res.second,res.first,0,1,1,n);
|
||||
int tmp=calu(res.first,res.second,m,a,b);
|
||||
ed[tmp]=tmp+m-1; bit.insert(tmp,1);
|
||||
printf("%d\n",tmp);
|
||||
int len,st;
|
||||
if(judge(res.first,tmp-1,len,st)) seg.updata(len,st,1,1,1,n);
|
||||
if(judge(ed[tmp]+1,res.first+res.second-1,len,st)) seg.updata(len,st,1,1,1,n);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(ed_len<m) puts("-1");
|
||||
else
|
||||
{
|
||||
int tmp=n-ed_len+1;
|
||||
ed[tmp]=tmp+m-1; ed_len=n-ed[tmp]; bit.insert(tmp,1);
|
||||
printf("%d\n",tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int k; scanf("%d",&k);
|
||||
if(k>bit.getsum()||k<=0) continue;
|
||||
int st=bit.query(k);
|
||||
int st1=1;
|
||||
if(k>1) st1=ed[bit.query(k-1)]+1;
|
||||
int len1=st-st1;
|
||||
if(len1>0&&st1!=1) seg.updata(len1,st1,0,1,1,n);
|
||||
int st2=bit.query(k+1)-1,len2;
|
||||
if(st2>n) len2=0,st2=n;
|
||||
else len2=st2-ed[st];
|
||||
if(len2>0&&!(st2==n)) seg.updata(len2,ed[st]+1,0,1,1,n);
|
||||
if(st1!=1&&st2!=n) seg.updata(st2-st1+1,st1,1,1,1,n);
|
||||
if(st1==1) st_len=st2-st1+1;
|
||||
if(st2==n) ed_len=st2-st1+1;
|
||||
bit.insert(st,-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int t,n,k;
|
||||
int count=1;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&k);
|
||||
printf("Case %d: ",count++);
|
||||
if(k==1&&(n%2==1)) puts("first");
|
||||
else if(n<=k) puts("first");
|
||||
else puts("second");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos(-1.0);
|
||||
struct Point {
|
||||
double x, y;
|
||||
Point operator - (const Point& t) const {
|
||||
Point tmp;
|
||||
tmp.x = x - t.x;
|
||||
tmp.y = y - t.y;
|
||||
return tmp;
|
||||
}
|
||||
Point operator + (const Point& t) const {
|
||||
Point tmp;
|
||||
tmp.x = x + t.x;
|
||||
tmp.y = y + t.y;
|
||||
return tmp;
|
||||
}
|
||||
bool operator == (const Point& t) const {
|
||||
return fabs(x-t.x) < eps && fabs(y-t.y) < eps;
|
||||
}
|
||||
};
|
||||
struct pol{
|
||||
Point node[11];
|
||||
int num;
|
||||
}P[11];
|
||||
inline double Cross(Point a, Point b, Point c) {
|
||||
return (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
|
||||
}
|
||||
bool dotOnSeg(Point p, Point s, Point e) {
|
||||
if ( p == s || p == e ) // 蜂电规娉
|
||||
return true;
|
||||
return Cross(p,s,e) < eps &&
|
||||
(p.x-s.x)*(p.x-e.x)<eps && (p.y-s.y)*(p.y-e.y)<eps;
|
||||
}
|
||||
struct Line {
|
||||
double a, b, c;
|
||||
};
|
||||
Line Turn(Point s, Point e) {
|
||||
Line ln;
|
||||
ln.a = s.y - e.y;
|
||||
ln.b = e.x - s.x;
|
||||
ln.c = s.x*e.y - e.x*s.y;
|
||||
return ln;
|
||||
}
|
||||
bool Line_Inst(Line l1, Line l2, Point &p) {
|
||||
double d = l1.a*l2.b - l2.a*l1.b;
|
||||
if ( fabs(d) < eps ) return false;
|
||||
p.x = (-l1.c*l2.b + l2.c*l1.b) / d;
|
||||
p.y = (-l1.a*l2.c + l2.a*l1.c) / d;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,k,cases=1;
|
||||
scanf("%d",&t);
|
||||
int x,y,m,n,ans;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&P[i].num);
|
||||
for(j=1;j<=P[i].num;j++)
|
||||
scanf("%lf%lf",&P[i].node[j].x,&P[i].node[j].y);
|
||||
}
|
||||
if(n<=2){ printf("Case %d: %d\n",cases++,n);continue;}
|
||||
Point p;
|
||||
int max=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=i+1;j<=n;j++)
|
||||
{
|
||||
for(k=1;k<=P[i].num;k++)
|
||||
{
|
||||
for(m=1;m<=P[j].num;m++)
|
||||
{
|
||||
ans=2;
|
||||
Line a=Turn(P[i].node[k],P[j].node[m]) ;
|
||||
for(x=1;x<=n;x++)
|
||||
{
|
||||
if(x==i||x==j) continue;
|
||||
for(y=1;y<P[x].num;y++)
|
||||
{
|
||||
Line b=Turn(P[x].node[y],P[x].node[y+1]);
|
||||
if(Line_Inst(a,b,p)&&dotOnSeg(p,P[x].node[y],P[x].node[y+1]))
|
||||
{
|
||||
ans++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans>max) max=ans;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d\n",cases++,max);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define LL(x) (x<<1)
|
||||
#define RR(x) (x<<1|1)
|
||||
#define MID(a,b) (a+((b-a)>>1))
|
||||
#define INF (1<<30)
|
||||
const int N=10000+5;
|
||||
typedef long long LL;
|
||||
struct node
|
||||
{
|
||||
int lft,rht;
|
||||
LL level,mx,flag,need;
|
||||
int mid(){return MID(lft,rht);}
|
||||
void init(){level=1;mx=0;flag=0;}
|
||||
void fun(LL valu)
|
||||
{
|
||||
mx+=level*valu;
|
||||
need-=valu;
|
||||
flag+=valu;
|
||||
}
|
||||
};
|
||||
int n,m,k;
|
||||
LL ned[12];
|
||||
struct Segtree
|
||||
{
|
||||
node tree[N*4];
|
||||
void down(int ind)
|
||||
{
|
||||
if(tree[ind].flag)
|
||||
{
|
||||
tree[LL(ind)].fun(tree[ind].flag);
|
||||
tree[RR(ind)].fun(tree[ind].flag);
|
||||
tree[ind].flag=0;
|
||||
}
|
||||
}
|
||||
void up(int ind)
|
||||
{
|
||||
tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
|
||||
tree[ind].level=max(tree[LL(ind)].level,tree[RR(ind)].level);
|
||||
tree[ind].need=min(tree[LL(ind)].need,tree[RR(ind)].need);
|
||||
}
|
||||
void build(int lft,int rht,int ind)
|
||||
{
|
||||
tree[ind].lft=lft; tree[ind].rht=rht;
|
||||
tree[ind].init(); tree[ind].need=ned[2];
|
||||
if(lft!=rht)
|
||||
{
|
||||
int mid=tree[ind].mid();
|
||||
build(lft,mid,LL(ind));
|
||||
build(mid+1,rht,RR(ind));
|
||||
}
|
||||
}
|
||||
void updata(int st,int ed,int ind,int valu)
|
||||
{
|
||||
int lft=tree[ind].lft,rht=tree[ind].rht;
|
||||
if(st<=lft&&rht<=ed)
|
||||
{
|
||||
if(valu>=tree[ind].need)
|
||||
{
|
||||
if(lft==rht)
|
||||
{
|
||||
LL &now=tree[ind].level;
|
||||
tree[ind].mx+=now*valu;
|
||||
while(tree[ind].mx>=ned[now+1]) now++;
|
||||
LL tmp=ned[now+1]-tree[ind].mx;
|
||||
tree[ind].need=tmp/now+(tmp%now!=0);
|
||||
}
|
||||
else
|
||||
{
|
||||
down(ind);
|
||||
int mid=tree[ind].mid();
|
||||
if(st<=mid) updata(st,ed,LL(ind),valu);
|
||||
if(ed> mid) updata(st,ed,RR(ind),valu);
|
||||
up(ind);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
tree[ind].fun(valu);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
down(ind);
|
||||
int mid=tree[ind].mid();
|
||||
if(st<=mid) updata(st,ed,LL(ind),valu);
|
||||
if(ed> mid) updata(st,ed,RR(ind),valu);
|
||||
up(ind);
|
||||
}
|
||||
}
|
||||
LL query(int st,int ed,int ind)
|
||||
{
|
||||
int lft=tree[ind].lft,rht=tree[ind].rht;
|
||||
if(st<=lft&&rht<=ed) return tree[ind].mx;
|
||||
else
|
||||
{
|
||||
down(ind);
|
||||
int mid=tree[ind].mid();
|
||||
LL mx1=0,mx2=0;
|
||||
if(st<=mid) mx1=query(st,ed,LL(ind));
|
||||
if(ed> mid) mx2=query(st,ed,RR(ind));
|
||||
up(ind);
|
||||
return max(mx1,mx2);
|
||||
}
|
||||
}
|
||||
}seg;
|
||||
int main()
|
||||
{
|
||||
int t,t_cnt=0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&k,&m);
|
||||
ned[1]=0; ned[k+1]=((LL)1<<60);
|
||||
for(int i=2;i<=k;i++) scanf("%I64d",&ned[i]);
|
||||
printf("Case %d:\n",++t_cnt);
|
||||
seg.build(1,n,1);
|
||||
while(m--)
|
||||
{
|
||||
char cmd[5];
|
||||
int a,b,c;
|
||||
scanf("%s",cmd);
|
||||
if(cmd[0]=='W')
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
seg.updata(a,b,1,c);
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
printf("%I64d\n",seg.query(a,b,1));
|
||||
}
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
# include<stdio.h>
|
||||
# include<string.h>
|
||||
# include<stdlib.h>
|
||||
# include<queue>
|
||||
# define N 105
|
||||
using namespace std;
|
||||
int n,m,MP;
|
||||
bool map[N][N][10];
|
||||
bool visit[N][N];
|
||||
int x0,y0,endx,endy;
|
||||
int dir1[6][2]={-1,1, 0,1, 1,1, 1,0, 0,-1, -1,0};
|
||||
int dir2[6][2]={-1,0, 0,1, 1,0, 1,-1, 0,-1, -1,-1};
|
||||
struct node{
|
||||
int x,y;
|
||||
int sum;
|
||||
bool operator<(const node &b) const
|
||||
{
|
||||
return b.sum < sum;
|
||||
}
|
||||
};
|
||||
int MIN(int a,int b)
|
||||
{
|
||||
return a<b?a:b;
|
||||
}
|
||||
bool is(int xx,int yy)
|
||||
{
|
||||
if(xx<0 || xx>=n || yy<0 || yy>=m) return 0;
|
||||
return 1;
|
||||
}
|
||||
bool is1(int xx,int yy)
|
||||
{
|
||||
int i,x1,y1;
|
||||
if(xx%2==1)
|
||||
{
|
||||
for(i=0;i<6;i++)
|
||||
{
|
||||
x1=xx+dir1[i][0];
|
||||
y1=yy+dir1[i][1];
|
||||
if(is(x1,y1) && map[x1][y1][3]) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(i=0;i<6;i++)
|
||||
{
|
||||
x1=xx+dir2[i][0];
|
||||
y1=yy+dir2[i][1];
|
||||
if(is(x1,y1) && map[x1][y1][3]) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
int bfs()
|
||||
{
|
||||
priority_queue<node>q;
|
||||
node cur,next;
|
||||
int i,cost,remain;
|
||||
cur.x=x0;
|
||||
cur.y=y0;
|
||||
cur.sum=0;
|
||||
while(!q.empty()) q.pop();
|
||||
q.push(cur);
|
||||
while(!q.empty())
|
||||
{
|
||||
cur=q.top();
|
||||
q.pop();
|
||||
remain=MP-cur.sum%MP;
|
||||
if(cur.x==endx && cur.y==endy)
|
||||
{
|
||||
if(remain==MP) return cur.sum/MP;
|
||||
else return cur.sum/MP+1;
|
||||
}
|
||||
if(visit[cur.x][cur.y]) continue;
|
||||
visit[cur.x][cur.y]=1;
|
||||
for(i=0;i<6;i++)
|
||||
{
|
||||
if(cur.x%2==1)
|
||||
{
|
||||
next.x=cur.x+dir1[i][0];
|
||||
next.y=cur.y+dir1[i][1];
|
||||
}
|
||||
else
|
||||
{
|
||||
next.x=cur.x+dir2[i][0];
|
||||
next.y=cur.y+dir2[i][1];
|
||||
}
|
||||
if(!(is(next.x,next.y)) || map[next.x][next.y][3]) continue;
|
||||
if(is1(cur.x,cur.y) && is1(next.x,next.y))
|
||||
{
|
||||
next.sum=cur.sum+remain;
|
||||
q.push(next);
|
||||
}
|
||||
else if(map[cur.x][cur.y][2] && map[next.x][next.y][2])
|
||||
{
|
||||
next.sum=cur.sum+1;
|
||||
q.push(next);
|
||||
}
|
||||
else if(map[cur.x][cur.y][i+4])
|
||||
{
|
||||
next.sum=cur.sum+remain;
|
||||
q.push(next);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(map[next.x][next.y][0]) cost=1;
|
||||
else cost=2;
|
||||
cost *=4;
|
||||
next.sum=cur.sum+MIN(cost,remain);
|
||||
q.push(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,ncase,t,k;
|
||||
int a[10],ans;
|
||||
a[0]=1;
|
||||
for(i=1;i<10;i++)
|
||||
a[i]=a[i-1]*2;
|
||||
scanf("%d",&ncase);
|
||||
for(t=1;t<=ncase;t++)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&MP);
|
||||
MP*=4;
|
||||
memset(map,0,sizeof(map));
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&ans);
|
||||
for(k=9;k>=0;k--)
|
||||
if(ans>=a[k])
|
||||
{
|
||||
map[i][j][k]=1;
|
||||
ans-=a[k];
|
||||
}
|
||||
}
|
||||
scanf("%d%d%d%d",&x0,&y0,&endx,&endy);
|
||||
memset(visit,0,sizeof(visit));
|
||||
printf("Case %d: %d\n",t,bfs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
# include<stdio.h>
|
||||
# include<string.h>
|
||||
# define cc 100
|
||||
# define rr 60
|
||||
# define V 6000
|
||||
int U[V],D[V];
|
||||
int L[V],R[V];
|
||||
int C[V],ROW[V];
|
||||
int H[rr],S[cc];
|
||||
int mark[rr],visit[27],size,ak;
|
||||
struct node{
|
||||
int m;
|
||||
int num1,num2;
|
||||
int a[11][2],b[11][2];
|
||||
}s[27];
|
||||
void Link(int r,int c)
|
||||
{
|
||||
S[c]++;
|
||||
C[size]=c;
|
||||
ROW[size]=r;
|
||||
U[size]=U[c];D[U[c]]=size;
|
||||
D[size]=c;U[c]=size;
|
||||
if(H[r]==-1) H[r]=L[size]=R[size]=size;
|
||||
else
|
||||
{
|
||||
L[size]=L[H[r]];R[L[H[r]]]=size;
|
||||
R[size]=H[r];L[H[r]]=size;
|
||||
}
|
||||
size++;
|
||||
}
|
||||
void remove(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
{
|
||||
L[R[i]]=L[i];
|
||||
R[L[i]]=R[i];
|
||||
}
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=U[c];i!=c;i=U[i])
|
||||
L[R[i]]=R[L[i]]=i;
|
||||
}
|
||||
int h()
|
||||
{
|
||||
int i,j,k,count=0;
|
||||
bool hash[cc];
|
||||
memset(hash,0,sizeof(hash));
|
||||
for(i=R[0];i;i=R[i])
|
||||
{
|
||||
if(hash[i]) continue;
|
||||
hash[i]=1;
|
||||
count++;
|
||||
for(j=D[i];j!=i;j=D[j])
|
||||
for(k=R[j];k!=j;k=R[k])
|
||||
hash[C[k]]=1;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
void Dance(int k)
|
||||
{
|
||||
int j,i,c,Min;
|
||||
if(k+h()>=ak) return;
|
||||
if(!R[0])
|
||||
{
|
||||
if(k<ak) ak=k;
|
||||
return;
|
||||
}
|
||||
for(Min=rr,i=R[0];i;i=R[i])
|
||||
if(Min>S[i]) Min=S[i],c=i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
{
|
||||
if(visit[mark[ROW[i]]]) continue;
|
||||
visit[mark[ROW[i]]]=1;
|
||||
remove(i);
|
||||
for(j=R[i];j!=i;j=R[j])
|
||||
remove(j);
|
||||
Dance(k+1);
|
||||
for(j=L[i];j!=i;j=L[j])
|
||||
resume(j);
|
||||
resume(i);
|
||||
visit[mark[ROW[i]]]=0;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,ncase,t,n,sum[26],number,mob,k,c,r;
|
||||
scanf("%d",&ncase);
|
||||
for(t=1;t<=ncase;t++)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
sum[0]=1;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&s[i].m);
|
||||
scanf("%d",&s[i].num1);
|
||||
for(k=0;k<s[i].num1;k++)
|
||||
scanf("%d%d",&s[i].a[k][0],&s[i].a[k][1]);
|
||||
if(s[i].m==2)
|
||||
{
|
||||
scanf("%d",&s[i].num2);
|
||||
for(k=0;k<s[i].num2;k++)
|
||||
scanf("%d%d",&s[i].b[k][0],&s[i].b[k][1]);
|
||||
}
|
||||
sum[i+1]=sum[i]+s[i].m;
|
||||
}
|
||||
c=sum[n]-1;
|
||||
for(i=0;i<=c;i++)
|
||||
{
|
||||
S[i]=0;
|
||||
U[i]=D[i]=i;
|
||||
L[i+1]=i;R[i]=i+1;
|
||||
}R[c]=0;
|
||||
size=c+1;
|
||||
r=0;
|
||||
memset(H,-1,sizeof(H));
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
r++;
|
||||
mark[r]=i;
|
||||
for(j=0;j<s[i].num1;j++)
|
||||
{
|
||||
number=s[i].a[j][0];
|
||||
mob=s[i].a[j][1];
|
||||
Link(r,sum[number]+mob);
|
||||
}
|
||||
for(j=0;j<s[i].m;j++)
|
||||
Link(r,sum[i]+j);
|
||||
if(s[i].m==2)
|
||||
{
|
||||
r++;
|
||||
mark[r]=i;
|
||||
for(j=0;j<s[i].num2;j++)
|
||||
{
|
||||
number=s[i].b[j][0];
|
||||
mob=s[i].b[j][1];
|
||||
Link(r,sum[number]+mob);
|
||||
}
|
||||
for(j=0;j<s[i].m;j++)
|
||||
Link(r,sum[i]+j);
|
||||
}
|
||||
}
|
||||
memset(visit,0,sizeof(visit));
|
||||
ak=n;
|
||||
Dance(0);
|
||||
printf("Case %d: %d\n",t,ak);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,315 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <stack>
|
||||
#include <cctype>
|
||||
#include <utility>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <climits>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
#include <ctime>
|
||||
using std::priority_queue;
|
||||
using std::vector;
|
||||
using std::swap;
|
||||
using std::stack;
|
||||
using std::sort;
|
||||
using std::max;
|
||||
using std::min;
|
||||
using std::pair;
|
||||
using std::map;
|
||||
using std::string;
|
||||
using std::cin;
|
||||
using std::cout;
|
||||
using std::set;
|
||||
using std::queue;
|
||||
using std::string;
|
||||
using std::stringstream;
|
||||
using std::make_pair;
|
||||
using std::getline;
|
||||
using std::greater;
|
||||
using std::endl;
|
||||
using std::multimap;
|
||||
using std::deque;
|
||||
using std::random_shuffle;
|
||||
typedef long long LL;
|
||||
typedef unsigned long long ULL;
|
||||
typedef pair<int, int> PAIR;
|
||||
typedef multimap<int, int> MMAP;
|
||||
typedef LL TY;
|
||||
const int MAXN(10010);
|
||||
const int MAXM(5010);
|
||||
const int MAXE(10010);
|
||||
const int MAXK(6);
|
||||
const int HSIZE(13131);
|
||||
const int SIGMA_SIZE(26);
|
||||
const int MAXH(19);
|
||||
const int INFI((INT_MAX-1) >> 1);
|
||||
const ULL BASE(31);
|
||||
const LL LIM(10000000);
|
||||
const int INV(-10000);
|
||||
const int MOD(65521);
|
||||
template<typename T> void checkmax(T &a, T b){if(b > a) a = b;}
|
||||
template<typename T> void checkmin(T &a, T b){if(b < a) a = b;}
|
||||
template<typename T> T ABS(const T &a){return a < 0? -a: a;}
|
||||
int pre[21][10][MAXN], opt[21][10][MAXN];
|
||||
int MM;
|
||||
struct HASH_MAP
|
||||
{
|
||||
int first[HSIZE], value[MAXN], next[MAXN];
|
||||
LL state[MAXN];
|
||||
int size;
|
||||
void init()
|
||||
{
|
||||
memset(first, -1, sizeof(first));
|
||||
size = 0;
|
||||
}
|
||||
void insert(LL ts, int tv, int x, int y, int pid, int op)
|
||||
{
|
||||
int h = ts%HSIZE;
|
||||
for(int i = first[h]; ~i; i = next[i])
|
||||
if(state[i] == ts)
|
||||
{
|
||||
if(tv > value[i])
|
||||
{
|
||||
pre[x][y][i] = pid;
|
||||
opt[x][y][i] = op;
|
||||
value[i] = tv;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
checkmax(MM, size);
|
||||
pre[x][y][size] = pid;
|
||||
opt[x][y][size] = op;
|
||||
state[size] = ts;
|
||||
value[size] = tv;
|
||||
next[size] = first[h];
|
||||
first[h] = size++;
|
||||
}
|
||||
} hm[2];
|
||||
HASH_MAP *cur, *last;
|
||||
int N, M;
|
||||
int code[11], path[11];
|
||||
int Num[8];
|
||||
char mp[21][15];
|
||||
void decode(LL ts)
|
||||
{
|
||||
for(int i = 0; i <= M; ++i)
|
||||
{
|
||||
code[i] = ts&7;
|
||||
path[i] = ts&8;
|
||||
ts >>= 4;
|
||||
}
|
||||
}
|
||||
LL encode()
|
||||
{
|
||||
LL ret = 0;
|
||||
memset(Num, -1, sizeof(Num));
|
||||
int cnt = 0;
|
||||
for(int i = M; i >= 0; --i)
|
||||
if(code[i] == 0)
|
||||
ret = (ret << 4)|path[i];
|
||||
else
|
||||
{
|
||||
if(Num[code[i]] == -1) Num[code[i]] = ++cnt;
|
||||
ret = (ret << 4)|Num[code[i]]|path[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void updata(int x, int y, int tv, int pid)
|
||||
{
|
||||
int lc = (y == 0)? 0: code[y];
|
||||
int uc = (x == 0)? 0: code[y+1];
|
||||
int lp = (y == 0)? 0: path[y-1];
|
||||
int up = (x == 0)? 0: path[y+1];
|
||||
if(mp[x][y] == 'S' || mp[x][y] == 'T')
|
||||
{
|
||||
if(lc == 0 && uc == 0)
|
||||
{
|
||||
if(lp || up) return;
|
||||
if(x < N-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = 7;
|
||||
code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
if(y < M-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = 0;
|
||||
code[y+1] = 7;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
}
|
||||
else
|
||||
if(lc == 0 || uc == 0)
|
||||
{
|
||||
if(lc)
|
||||
{
|
||||
if(up) return;
|
||||
path[y] = 8;
|
||||
code[y] = code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(lp) return;
|
||||
path[y] = 8;
|
||||
code[y] = code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(mp[x][y] == 'B')
|
||||
{
|
||||
if(lc == 0 && uc == 0)
|
||||
{
|
||||
path[y] = 0;
|
||||
code[y] = code[y+1] = 0;
|
||||
cur->insert(encode(), tv, x, y, pid, 0);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(lc == 0 && uc == 0)
|
||||
{
|
||||
path[y] = 0;
|
||||
code[y] = code[y+1] = 0;
|
||||
cur->insert(encode(), tv, x, y, pid, 0);
|
||||
if(x == N-1 || y == M-1) return;
|
||||
if(lp || up) return;
|
||||
path[y] = 8;
|
||||
code[y] = code[y+1] = 7;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
else
|
||||
if(lc == 0 || uc == 0)
|
||||
{
|
||||
if(lc)
|
||||
{
|
||||
if(up) return;
|
||||
if(x < N-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = lc;
|
||||
code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
if(y < M-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = 0;
|
||||
code[y+1] = lc;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(lp) return;
|
||||
if(x < N-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = uc;
|
||||
code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
if(y < M-1)
|
||||
{
|
||||
path[y] = 8;
|
||||
code[y] = 0;
|
||||
code[y+1] = uc;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
if(lc != uc)
|
||||
{
|
||||
path[y] = 8;
|
||||
for(int i = 0; i <= M; ++i)
|
||||
if(code[i] == uc) code[i] = lc;
|
||||
code[y] = code[y+1] = 0;
|
||||
cur->insert(encode(), tv+1, x, y, pid, 1);
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
cur = hm;
|
||||
last = hm+1;
|
||||
last->init();
|
||||
last->insert(0, 0, 0, 0, 0, 0);
|
||||
for(int i = 0; i < N; ++i)
|
||||
{
|
||||
int sz = last->size;
|
||||
for(int j = 0; j < sz; ++j)
|
||||
last->state[j] <<= 4;
|
||||
for(int j = 0; j < M; ++j)
|
||||
{
|
||||
cur->init();
|
||||
sz = last->size;
|
||||
for(int k = 0; k < sz; ++k)
|
||||
{
|
||||
decode(last->state[k]);
|
||||
updata(i, j, last->value[k], k);
|
||||
}
|
||||
swap(cur, last);
|
||||
}
|
||||
}
|
||||
int ans = 0, id;
|
||||
for(int i = 0; i < last->size; ++i)
|
||||
{
|
||||
decode(last->state[i]);
|
||||
bool flag(true);
|
||||
for(int j = 0; j <= M; ++j)
|
||||
if(code[j])
|
||||
{
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
if(last->value[i] > ans)
|
||||
{
|
||||
ans = last->value[i];
|
||||
id = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i = 0; i < N; ++i)
|
||||
for(int j = 0; j < M; ++j)
|
||||
if(mp[i][j] == '.')
|
||||
mp[i][j] = 'W';
|
||||
for(int i = N-1; i >= 0; --i)
|
||||
for(int j = M-1; j >= 0; --j)
|
||||
{
|
||||
if(mp[i][j] == 'W' && opt[i][j][id]) mp[i][j] = '.';
|
||||
id = pre[i][j][id];
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
for(int i = 0; i < N; ++i)
|
||||
printf("%s\n", mp[i]);
|
||||
printf("\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int TC, n_case(0);
|
||||
scanf("%d", &TC);
|
||||
while(TC--)
|
||||
{
|
||||
scanf("%d%d", &N, &M);
|
||||
for(int i = 0; i < N; ++i)
|
||||
scanf("%s", mp[i]);
|
||||
printf("Case %d: ", ++n_case);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include<stdio.h>
|
||||
long long gcd(long long a,long long b)
|
||||
{
|
||||
if(b==0) return a;
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int s,m,n,i,j,count=1;
|
||||
long long sum,t;
|
||||
scanf("%d",&s);
|
||||
while(s--)
|
||||
{
|
||||
sum=1;
|
||||
scanf("%d %d",&n,&m);
|
||||
for(i=1;i<=110;i++)
|
||||
{
|
||||
sum=sum*m;
|
||||
if(sum>=n) break;
|
||||
}
|
||||
sum=sum*i;
|
||||
t=gcd(sum,n);
|
||||
sum=sum/t;n=n/t;
|
||||
printf("Case %d: %lld/%d\n",count++,sum,n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#define sqr(x) ((x)*(x))
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const double eps=1e-9;
|
||||
const double pi=acos(-1.0);
|
||||
struct point
|
||||
{
|
||||
double x, y;
|
||||
point() {}
|
||||
point(double xx, double yy):x(xx), y(yy) {}
|
||||
point operator + (const point &a) const
|
||||
{
|
||||
return point(x+a.x, y+a.y);
|
||||
}
|
||||
point operator - (const point &a) const
|
||||
{
|
||||
return point(x-a.x, y-a.y);
|
||||
}
|
||||
} po[105], cen, s, e, tp[105];
|
||||
double r;
|
||||
int t1, t2, t;
|
||||
int n, pn;
|
||||
point cg()
|
||||
{
|
||||
point p, s, re;
|
||||
re.x=0.0;
|
||||
re.y=0.0;
|
||||
double area=0.0, ar;
|
||||
p=po[0];
|
||||
po[n]=po[0];
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
s=po[i];
|
||||
ar=p.x*s.y-s.x*p.y;
|
||||
area+=(ar/2);
|
||||
re.x+=(p.x+s.x)*ar;
|
||||
re.y+=(p.y+s.y)*ar;
|
||||
p=s;
|
||||
}
|
||||
re.x/=(6*area);
|
||||
re.y/=(6*area);
|
||||
return re;
|
||||
}
|
||||
point pointrotate(point o, double ang, point p)
|
||||
{
|
||||
point tp;
|
||||
p.x-=o.x;
|
||||
p.y-=o.y;
|
||||
tp.x=p.x*cos(ang)-p.y*sin(ang)+o.x;
|
||||
tp.y=p.y*cos(ang)+p.x*sin(ang)+o.y;
|
||||
return tp;
|
||||
}
|
||||
double dis(point a, point b)
|
||||
{
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
double dot(point sp, point ep, point op)
|
||||
{
|
||||
return (sp.x-op.x)*(ep.x-op.x)+(sp.y-op.y)*(ep.y-op.y);
|
||||
}
|
||||
double cross(point sp, point ep, point op)
|
||||
{
|
||||
return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x);
|
||||
}
|
||||
double coverdeg(double ang, double d, double r)
|
||||
{
|
||||
double neg=1;
|
||||
if(ang<0)
|
||||
{
|
||||
ang=-ang;
|
||||
neg=-1;
|
||||
}
|
||||
double sina=d*sin(ang)/r;
|
||||
if(sina>1)sina=1;
|
||||
return neg*(asin(sina)-ang);
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
int i;
|
||||
while(~scanf("%lf%lf%lf%lf%lf%d%d%d%d", &s.x, &s.y, &e.x, &e.y, &r, &n, &t1, &t2, &t))
|
||||
{
|
||||
for(i=0; i<n; i++)scanf("%lf%lf", &po[i].x, &po[i].y);
|
||||
cen=cg();
|
||||
double a2=(double)(t%t2)/t2*2*pi;
|
||||
for(i=0; i<n; i++)po[i]=pointrotate(cen, a2, po[i]);
|
||||
double a1=(double)(t%t1)/t1*2*pi;
|
||||
point newcen=pointrotate(e, a1, cen);
|
||||
point mov=newcen-cen;
|
||||
for(i=0; i<n; i++)po[i]=po[i]+mov;
|
||||
double se=dis(s, e);
|
||||
double maxang=acos(r/se);
|
||||
double maxarc=2*maxang*r;
|
||||
if(dot(s, newcen, e)<0)
|
||||
{
|
||||
printf("%.2lf\n", maxarc);
|
||||
continue;
|
||||
}
|
||||
double supang=pi*0.5-maxang;
|
||||
point up=po[0], lp=po[0];
|
||||
for(int i=1; i<n; i++)
|
||||
{
|
||||
if(cross(up, po[i], s)>eps)up=po[i];
|
||||
if(cross(lp, po[i], s)<-eps)lp=po[i];
|
||||
}
|
||||
double ua=acos(dot(up, e, s)/(se*dis(s, up)));
|
||||
double la=acos(dot(lp, e, s)/(se*dis(s, lp)));
|
||||
if(cross(e, up, s)<0)ua=-ua;
|
||||
if(cross(e, lp, s)<0)la=-la;
|
||||
double cvua=min(supang, ua), cvla=max(-supang, la);
|
||||
if(cvua<cvla)
|
||||
{
|
||||
printf("%.2lf\n", maxarc);
|
||||
continue;
|
||||
}
|
||||
double coverarc=r*(coverdeg(cvua, se, r)-coverdeg(cvla, se, r));
|
||||
printf("%.2lf\n", maxarc-coverarc);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define MAX 40
|
||||
#define MOD 10007
|
||||
char dir[MAX];
|
||||
int hash[256],n,m,total;
|
||||
struct node {
|
||||
int flag,in;
|
||||
node *fail,*next[4];
|
||||
}*qu[MAX*MAX],arr[MAX*MAX],*root;
|
||||
node *CreateNode() {
|
||||
node *p = &arr[total];
|
||||
p->in = total++;
|
||||
p->flag = 0;
|
||||
p->fail = NULL;
|
||||
for (int i = 0; i < 4; ++i)
|
||||
p->next[i] = NULL;
|
||||
return p;
|
||||
}
|
||||
void Insert(char *str) {
|
||||
int i = 0,k;
|
||||
node *p = root;
|
||||
while (str[i]) {
|
||||
k = hash[str[i++]];
|
||||
if (p->next[k] == NULL)
|
||||
p->next[k] = CreateNode();
|
||||
p = p->next[k];
|
||||
}
|
||||
p->flag = 1;
|
||||
}
|
||||
void Build_AC() {
|
||||
int head,tail,i;
|
||||
head = tail = 0;
|
||||
root->fail = root;
|
||||
qu[++head] = root;
|
||||
while (tail < head) {
|
||||
node *p = qu[++tail];
|
||||
for (i = 0; i < 4; ++i) {
|
||||
if (p->next[i] != NULL) {
|
||||
if (p == root) p->next[i]->fail = root;
|
||||
else p->next[i]->fail = p->fail->next[i];
|
||||
qu[++head] = p->next[i];
|
||||
p->next[i]->flag |= p->fail->next[i]->flag;
|
||||
}
|
||||
else {
|
||||
if (p == root) p->next[i] = root;
|
||||
else p->next[i] = p->fail->next[i];
|
||||
}//else
|
||||
}//for
|
||||
}//while
|
||||
}//void
|
||||
struct Mat{
|
||||
int mat[MAX*2][MAX*2],size;
|
||||
Mat(int n) {size = n,memset(mat,0,sizeof(mat));}
|
||||
Mat(int arr[][MAX*2],int n) { size = n,memcpy(mat,arr,sizeof(arr));}
|
||||
friend Mat operator *(Mat a,Mat b);
|
||||
friend Mat operator +(Mat a,Mat b);
|
||||
friend Mat operator ^(Mat a,int k);
|
||||
friend Mat Sum(Mat a,int k);
|
||||
}A(MAX*2),E(MAX*2);
|
||||
Mat operator *(Mat a,Mat b) {
|
||||
Mat c(total*2);
|
||||
for (int i = 0; i < c.size; ++i)
|
||||
for (int j = 0; j < c.size; ++j)
|
||||
for (int k = 0; k < c.size; ++k)
|
||||
if (a.mat[i][k] && b.mat[k][j]) {
|
||||
c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
|
||||
c.mat[i][j] %= MOD;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
Mat operator +(Mat a,Mat b) {
|
||||
Mat c(total*2);
|
||||
for (int i = 0; i < c.size; ++i)
|
||||
for (int j = 0; j < c.size; ++j)
|
||||
c.mat[i][j] = (a.mat[i][j] + b.mat[i][j]) % MOD;
|
||||
return c;
|
||||
}
|
||||
Mat operator ^(Mat a,int k) {
|
||||
Mat c = E;
|
||||
while (k) {
|
||||
if (k & 1) c = c * a;
|
||||
a = a * a,k >>= 1;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
Mat Sum(Mat A,int k) {
|
||||
if (k == 1) return A;
|
||||
else if (k & 1) return (A^k) * Sum(A,k-1);
|
||||
else return Sum(A,k/2) * ((A^(k/2)) + E);
|
||||
}
|
||||
void GetMat() {
|
||||
int i,j,k;
|
||||
Mat c(total*2);
|
||||
for (i = 0; i < total; ++i) {
|
||||
for (k = 0; k < 4; ++k) {
|
||||
j = arr[i].next[k]->in;
|
||||
if (arr[i].next[k]->flag)
|
||||
c.mat[i][j+total]++;
|
||||
else c.mat[i][j]++,c.mat[i+total][j+total]++;
|
||||
}
|
||||
}
|
||||
E = A = c;
|
||||
memset(E.mat,0,sizeof(E.mat));
|
||||
for (i = 0; i < E.size; ++i)
|
||||
E.mat[i][i] = 1;
|
||||
}
|
||||
int Solve_1A() {
|
||||
int i,j,k,ans,sum;
|
||||
ans = 1,k = n,sum = 4;
|
||||
while (k) {
|
||||
if (k & 1) ans = (ans * sum) % MOD;
|
||||
sum = (sum * sum) % MOD,k >>= 1;
|
||||
}
|
||||
A = A^n;
|
||||
for (i = 0; i < 2 * total; ++i)
|
||||
ans = (ans - A.mat[0][i] + MOD) % MOD;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,ans;
|
||||
hash['A'] = 0,hash['T'] = 1;
|
||||
hash['C'] = 2,hash['G'] = 3;
|
||||
while (scanf("%d%d",&m,&n) != EOF) {
|
||||
total = 0;
|
||||
root = CreateNode();
|
||||
for (i = 0; i < m; ++i)
|
||||
scanf("%s",dir),Insert(dir);
|
||||
Build_AC();
|
||||
GetMat();
|
||||
ans = Solve_1A();
|
||||
printf("%d\n",ans % MOD);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
bool map[15][15];
|
||||
bool mark[15];
|
||||
int val[15];
|
||||
int n;
|
||||
void dfs(int index,int num,int j)
|
||||
{
|
||||
int i;
|
||||
if(num>1&&map[index][j])
|
||||
{
|
||||
for(int k=0;k<num;k++)
|
||||
printf("%d",val[k]);
|
||||
printf("\n");
|
||||
}
|
||||
for(i=j+1;i<n;i++)
|
||||
{
|
||||
if(mark[i]==0&&map[index][i])
|
||||
{
|
||||
mark[i]=1;
|
||||
val[num]=i;
|
||||
dfs(i,num+1,j);
|
||||
mark[i]=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,a;
|
||||
//freopen("a.txt","r",stdin);
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
if(a==0)map[i][j]=0;
|
||||
else map[i][j]=1;
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
mark[j]=0;
|
||||
mark[i]=1;
|
||||
val[0]=i;
|
||||
dfs(i,1,i);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#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>
|
||||
using namespace std;
|
||||
const int MAXN = 50010;
|
||||
struct Edge
|
||||
{
|
||||
int to,next;
|
||||
}edge[MAXN*2];
|
||||
int head[MAXN],tot;
|
||||
int top[MAXN];
|
||||
int fa[MAXN];
|
||||
int deep[MAXN];
|
||||
int num[MAXN];
|
||||
int p[MAXN];
|
||||
int fp[MAXN];
|
||||
int son[MAXN];
|
||||
int pos;
|
||||
void init()
|
||||
{
|
||||
tot = 0;
|
||||
memset(head,-1,sizeof(head));
|
||||
pos = 1;
|
||||
memset(son,-1,sizeof(son));
|
||||
}
|
||||
void addedge(int u,int v)
|
||||
{
|
||||
edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
|
||||
}
|
||||
void dfs1(int u,int pre,int d)
|
||||
{
|
||||
deep[u] = d;
|
||||
fa[u] = pre;
|
||||
num[u] = 1;
|
||||
for(int i = head[u];i != -1; i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].to;
|
||||
if(v != pre)
|
||||
{
|
||||
dfs1(v,u,d+1);
|
||||
num[u] += num[v];
|
||||
if(son[u] == -1 || num[v] > num[son[u]])
|
||||
son[u] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
void getpos(int u,int sp)
|
||||
{
|
||||
top[u] = sp;
|
||||
p[u] = pos++;
|
||||
fp[p[u]] = u;
|
||||
if(son[u] == -1) return;
|
||||
getpos(son[u],sp);
|
||||
for(int i = head[u];i != -1;i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].to;
|
||||
if( v != son[u] && v != fa[u])
|
||||
getpos(v,v);
|
||||
}
|
||||
}
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x&(-x);
|
||||
}
|
||||
int c[MAXN];
|
||||
int n;
|
||||
int sum(int i)
|
||||
{
|
||||
int s = 0;
|
||||
while(i > 0)
|
||||
{
|
||||
s += c[i];
|
||||
i -= lowbit(i);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
void add(int i,int val)
|
||||
{
|
||||
while(i <= n)
|
||||
{
|
||||
c[i] += val;
|
||||
i += lowbit(i);
|
||||
}
|
||||
}
|
||||
void Change(int u,int v,int val)
|
||||
{
|
||||
int f1 = top[u], f2 = top[v];
|
||||
int tmp = 0;
|
||||
while(f1 != f2)
|
||||
{
|
||||
if(deep[f1] < deep[f2])
|
||||
{
|
||||
swap(f1,f2);
|
||||
swap(u,v);
|
||||
}
|
||||
add(p[f1],val);
|
||||
add(p[u]+1,-val);
|
||||
u = fa[f1];
|
||||
f1 = top[u];
|
||||
}
|
||||
if(deep[u] > deep[v]) swap(u,v);
|
||||
add(p[u],val);
|
||||
add(p[v]+1,-val);
|
||||
}
|
||||
int a[MAXN];
|
||||
int main()
|
||||
{
|
||||
int M,P;
|
||||
while(scanf("%d%d%d",&n,&M,&P) == 3)
|
||||
{
|
||||
int u,v;
|
||||
int C1,C2,K;
|
||||
char op[10];
|
||||
init();
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
}
|
||||
while(M--)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
addedge(u,v);
|
||||
addedge(v,u);
|
||||
}
|
||||
dfs1(1,0,0);
|
||||
getpos(1,1);
|
||||
memset(c,0,sizeof(c));
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
add(p[i],a[i]);
|
||||
add(p[i]+1,-a[i]);
|
||||
}
|
||||
while(P--)
|
||||
{
|
||||
scanf("%s",op);
|
||||
if(op[0] == 'Q')
|
||||
{
|
||||
scanf("%d",&u);
|
||||
printf("%d\n",sum(p[u]));
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d%d%d",&C1,&C2,&K);
|
||||
if(op[0] == 'D')
|
||||
K = -K;
|
||||
Change(C1,C2,K);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
__int64 a,b,k,num,dp[20][25],d[20][25],C[20],r[20][25],A[20];
|
||||
__int64 dfs(__int64 now,__int64 left)
|
||||
{
|
||||
if(now<0) return 0;
|
||||
__int64 sum=0,i,j,ii;
|
||||
for(i=0;i<A[now];i++)
|
||||
r[now][(left*10+i)%k]++;
|
||||
for(j=0;j<k;j++)
|
||||
{
|
||||
for(i=0;i<10;i++)
|
||||
r[now][(j*10+i)%k]+=r[now+1][j];
|
||||
ii=r[now+1][j];
|
||||
if(!j&&ii>0) ii--;
|
||||
sum+=ii*dp[now][((k-j)%k+k)%k];
|
||||
}
|
||||
if(now!=num)
|
||||
sum+=d[now][((k-left)%k+k)%k];
|
||||
sum+=dfs(now-1,(left*10+A[now])%k);
|
||||
return sum;
|
||||
}
|
||||
void dfs2()
|
||||
{
|
||||
__int64 i,j,now;
|
||||
memset(C,0,sizeof(C));
|
||||
C[0]=1%k;
|
||||
for(i=1;i<18;i++)
|
||||
C[i]=(C[i-1]*10)%k;
|
||||
for(i=0;i<=A[0];i++)
|
||||
d[0][i%k]++;
|
||||
for(now=1;now<=num;now++)
|
||||
{
|
||||
for(j=0;j<k;j++)
|
||||
{
|
||||
d[now][(A[now]*C[now]+j)%k]+=d[now-1][j];
|
||||
for(i=0;i<A[now];i++)
|
||||
d[now][(i*C[now]+j)%k]+=dp[now-1][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
__int64 Cal(__int64 a)
|
||||
{
|
||||
__int64 i=0;
|
||||
while(a)
|
||||
{
|
||||
A[i++]=a%10;
|
||||
a/=10;
|
||||
}
|
||||
num=i-1;
|
||||
memset(d,0,sizeof(d));
|
||||
memset(r,0,sizeof(r));
|
||||
dfs2();
|
||||
return dfs(num,0);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 i,j,ii;
|
||||
while(scanf("%I64d%I64d%I64d",&a,&b,&k)!=EOF)
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(i=0;i<10;i++)
|
||||
dp[0][i%k]++;
|
||||
for(i=1;i<18;i++)
|
||||
for(ii=0;ii<k;ii++)
|
||||
for(j=0;j<=9;j++)
|
||||
dp[i][(ii*10+j)%k]+=dp[i-1][ii];
|
||||
printf("%I64d\n",Cal(b)-Cal(a-1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <cstdio>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define forn(i, n) for(int i = 0; i < (int)(n); i++)
|
||||
#define clr(a, b) memset(a, b, sizeof(a))
|
||||
#define SZ(a) ((int)a.size())
|
||||
#define PB push_back
|
||||
#define MP make_pair
|
||||
#define inf 0x3f3f3f3f
|
||||
typedef vector<int> vi;
|
||||
typedef pair<int, int> pii;
|
||||
typedef long long ll;
|
||||
#ifdef ecust
|
||||
#define R "%lld"
|
||||
#else
|
||||
#define R "%I64d"
|
||||
#endif
|
||||
namespace acm {
|
||||
double x0, y0, x1, y1;
|
||||
double vx, vy;
|
||||
double t;
|
||||
double fun(double x){
|
||||
return 1.0/9.8*(x/2*sqrt(x*x+vx*vx)+vx*vx/2*log(x+sqrt(x*x+vx*vx)));
|
||||
}
|
||||
void solve(){
|
||||
scanf("%lf%lf%lf%lf%lf", &x0, &y0, &x1, &y1, &t);
|
||||
if(fabs(t) <= 1e-8) {puts("Impossible."); return;}
|
||||
vx = ((x1 - x0))/t;
|
||||
vy = ((y1 - y0) + 0.5*9.8*t*t)/t;
|
||||
printf("%.3lf\n", fun(vy)-fun(vy-9.8*t));
|
||||
}
|
||||
void icpc(){
|
||||
int cas; scanf("%d", &cas);
|
||||
while(cas--){
|
||||
solve();
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
acm::icpc();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
#include <iostream>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int i, j, t, n, k;
|
||||
char team1[55], team2[55], tmp[122], tmp1[55][55], tmp2[55][55], fk[9];
|
||||
bool chuchang[3][13];
|
||||
int score[5], pts[5][55], off[5][55], def[5][55], reb[5][55], ast[5][55], pf[5][55], free[5][55][5], three[5][55][5], faqiu[55][55][5], stl[5][55], block[5][55];
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
memset(chuchang, 0, sizeof(chuchang));
|
||||
memset(score, 0, sizeof(score));
|
||||
memset(pts, 0, sizeof(pts));
|
||||
memset(off, 0, sizeof(off));
|
||||
memset(def, 0, sizeof(def));
|
||||
memset(reb, 0, sizeof(reb));
|
||||
memset(ast, 0, sizeof(ast));
|
||||
memset(pf, 0, sizeof(pf));
|
||||
memset(free, 0, sizeof(free));
|
||||
memset(three, 0, sizeof(three));
|
||||
memset(faqiu, 0, sizeof(faqiu));
|
||||
memset(stl, 0, sizeof(stl));
|
||||
memset(block, 0, sizeof(block));
|
||||
map<string, int>teamnum;
|
||||
map<string, int>num;
|
||||
scanf("%s %s %s", team1, tmp, team2);
|
||||
for(i = 1; i <= 12; i++)
|
||||
{
|
||||
scanf("%s", tmp1[i]);
|
||||
string tmpname = tmp1[i];
|
||||
teamnum[tmpname] = 1;
|
||||
num[tmpname] = i;
|
||||
}
|
||||
for(i = 1; i <= 12; i++)
|
||||
{
|
||||
scanf("%s", tmp2[i]);
|
||||
string tmpname = tmp2[i];
|
||||
teamnum[tmpname] = 2;
|
||||
num[tmpname] = i;
|
||||
}
|
||||
scanf("%d", &n);
|
||||
string pre = "", now = "";
|
||||
bool ispass = 0, twoout = 0, threeout = 0, fa = 0, fangui = 0;
|
||||
getchar();
|
||||
for(k = 0; k < n; k++)
|
||||
{
|
||||
gets(tmp);
|
||||
if(k == 0 || k == n - 1) continue;
|
||||
string str = tmp;
|
||||
if(str.find("Hold Ball") != -1)
|
||||
{
|
||||
int len = str.length() - 10;
|
||||
string tt = str.substr(0, len);
|
||||
now = tt;
|
||||
fangui = false;
|
||||
}
|
||||
else if(str.find("Pass to") != -1)
|
||||
{
|
||||
string tt = "";
|
||||
int len = str.length();
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
if(str[i] == ' ') break;
|
||||
else tt += str[i];
|
||||
}
|
||||
pre = tt;
|
||||
ispass = true;
|
||||
now = str.substr(pre.length() + 9);
|
||||
}
|
||||
else if(str.find("Layup") != -1 || str.find("Slam Dunk") != -1 || str.find("Hook Shot") != -1 || str.find("Jump Shot") != -1 )
|
||||
twoout = true;
|
||||
else if(str.find("3pt Shot") != -1)
|
||||
threeout = true;
|
||||
else if(str.find("Missed") != -1)
|
||||
{
|
||||
if(fa == true)
|
||||
{
|
||||
faqiu[teamnum[now]][num[now]][2]++;
|
||||
fa = false;
|
||||
}
|
||||
else if(twoout == true)
|
||||
{
|
||||
if(!fangui) free[teamnum[now]][num[now]][2]++;
|
||||
else fangui = false;
|
||||
twoout = false;
|
||||
}
|
||||
else if(threeout == true)
|
||||
{
|
||||
if(!fangui)
|
||||
{
|
||||
free[teamnum[now]][num[now]][2]++;
|
||||
three[teamnum[now]][num[now]][2]++;
|
||||
}
|
||||
else fangui = false;
|
||||
threeout = false;
|
||||
}
|
||||
ispass = false;
|
||||
}
|
||||
else if(str.find("Made") != -1)
|
||||
{
|
||||
if(fa == true)
|
||||
{
|
||||
pts[teamnum[now]][num[now]]++;
|
||||
score[teamnum[now]]++;
|
||||
faqiu[teamnum[now]][num[now]][2]++;
|
||||
faqiu[teamnum[now]][num[now]][1]++;
|
||||
fa = false;
|
||||
}
|
||||
else if(twoout)
|
||||
{
|
||||
pts[teamnum[now]][num[now]] += 2;
|
||||
score[teamnum[now]] += 2;
|
||||
free[teamnum[now]][num[now]][1]++;
|
||||
free[teamnum[now]][num[now]][2]++;
|
||||
if(ispass)
|
||||
{
|
||||
ast[teamnum[now]][num[pre]]++;
|
||||
ispass = false;
|
||||
}
|
||||
twoout = false;
|
||||
}
|
||||
else if(threeout)
|
||||
{
|
||||
pts[teamnum[now]][num[now]] += 3;
|
||||
score[teamnum[now]] += 3;
|
||||
free[teamnum[now]][num[now]][1]++;
|
||||
free[teamnum[now]][num[now]][2]++;
|
||||
three[teamnum[now]][num[now]][2]++;
|
||||
three[teamnum[now]][num[now]][1]++;
|
||||
if(ispass)
|
||||
{
|
||||
ast[teamnum[now]][num[pre]]++;
|
||||
ispass = false;
|
||||
}
|
||||
threeout = false;
|
||||
}
|
||||
ispass = false;
|
||||
}
|
||||
else if(str.find("Rebound") != -1)
|
||||
{
|
||||
string tt = "";
|
||||
int len = str.length();
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
if(str[i] == ' ') break;
|
||||
else tt += str[i];
|
||||
}
|
||||
if(teamnum[tt] != teamnum[now])
|
||||
{
|
||||
def[teamnum[tt]][num[tt]]++;
|
||||
reb[teamnum[tt]][num[tt]]++;
|
||||
}
|
||||
else if(teamnum[tt] == teamnum[now])
|
||||
{
|
||||
off[teamnum[tt]][num[tt]]++;
|
||||
reb[teamnum[tt]][num[tt]]++;
|
||||
}
|
||||
now = tt;
|
||||
ispass = false;
|
||||
twoout = false;
|
||||
threeout = false;
|
||||
}
|
||||
else if(str.find("Blocked") != -1)
|
||||
{
|
||||
if(threeout)
|
||||
{
|
||||
free[teamnum[now]][num[now]][2]++;
|
||||
three[teamnum[now]][num[now]][2]++;
|
||||
threeout = false;
|
||||
}
|
||||
else if(twoout)
|
||||
{
|
||||
free[teamnum[now]][num[now]][2]++;
|
||||
twoout = false;
|
||||
}
|
||||
string tt = str.substr(11);
|
||||
block[teamnum[tt]][num[tt]]++;
|
||||
ispass = false;
|
||||
twoout = false;
|
||||
threeout = false;
|
||||
}
|
||||
else if(str.find("Foul") != -1)
|
||||
{
|
||||
string tt = "";
|
||||
int len = str.length();
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
if(str[i] == ' ') break;
|
||||
else tt += str[i];
|
||||
}
|
||||
pf[teamnum[tt]][num[tt]]++;
|
||||
if(twoout || threeout)
|
||||
fangui = true;
|
||||
}
|
||||
else if(str.find("Free Throw") != -1)
|
||||
{
|
||||
fa = true;
|
||||
ispass = false;
|
||||
}
|
||||
else if(str.find("Substitution") != -1)
|
||||
{
|
||||
int len = str.find("Substitution") + 25;
|
||||
string tt = str.substr(len);
|
||||
chuchang[teamnum[tt]][num[tt]] = 1;
|
||||
ispass = false;
|
||||
twoout = false;
|
||||
threeout = false;
|
||||
}
|
||||
else if(str.find("Timeout") != -1)
|
||||
ispass = false;
|
||||
else if(str.find("Jump Ball") != -1)
|
||||
ispass = false;
|
||||
else if(str.find("Steal") != -1)
|
||||
{
|
||||
string tt = "";
|
||||
int len = str.length();
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
if(str[i] == ' ') break;
|
||||
else tt += str[i];
|
||||
}
|
||||
stl[teamnum[tt]][num[tt]]++;
|
||||
now = tt;
|
||||
ispass = false;
|
||||
}
|
||||
}
|
||||
printf("%s %d-%d %s\n", team1, score[1], score[2], team2);
|
||||
printf("%s\n", team1);
|
||||
puts(" PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
|
||||
for(i = 1; i <= 12; i++)
|
||||
{
|
||||
if(i <= 5 || chuchang[1][i] == 1)
|
||||
{
|
||||
printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp1[i], pts[1][i], off[1][i], def[1][i], reb[1][i], ast[1][i], stl[1][i], block[1][i], pf[1][i]);
|
||||
sprintf(fk, "%d-%d", free[1][i][1], free[1][i][2]);
|
||||
printf("%6s", fk);
|
||||
sprintf(fk, "%d-%d", three[1][i][1], three[1][i][2]);
|
||||
printf("%6s", fk);
|
||||
sprintf(fk, "%d-%d", faqiu[1][i][1], faqiu[1][i][2]);
|
||||
printf("%6s\n", fk);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%20s", tmp1[i]);
|
||||
puts(" DNP - Coach's Decision");
|
||||
}
|
||||
}
|
||||
printf("%s\n", team2);
|
||||
puts(" PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
|
||||
for(i = 1; i <= 12; i++)
|
||||
{
|
||||
if(i <= 5 || chuchang[2][i] == 1)
|
||||
{
|
||||
printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp2[i], pts[2][i], off[2][i], def[2][i], reb[2][i], ast[2][i], stl[2][i], block[2][i], pf[2][i]);
|
||||
sprintf(fk, "%d-%d", free[2][i][1], free[2][i][2]);
|
||||
printf("%6s", fk);
|
||||
sprintf(fk, "%d-%d", three[2][i][1], three[2][i][2]);
|
||||
printf("%6s", fk);
|
||||
sprintf(fk, "%d-%d", faqiu[2][i][1], faqiu[2][i][2]);
|
||||
printf("%6s\n", fk);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%20s", tmp2[i]);
|
||||
puts(" DNP - Coach's Decision");
|
||||
}
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
namespace ST
|
||||
{
|
||||
typedef long long LL;
|
||||
const int maxn = 300010;
|
||||
LL a[maxn];
|
||||
LL Min[maxn<<2], Max[maxn<<2], add[maxn<<2];
|
||||
inline void pushUp(int rt)
|
||||
{
|
||||
Max[rt] = max(Max[rt<<1], Max[rt<<1|1]);
|
||||
Min[rt] = min(Min[rt<<1], Min[rt<<1|1]);
|
||||
}
|
||||
inline void modify(int rt, LL c)
|
||||
{
|
||||
add[rt] += c;
|
||||
Max[rt] += c;
|
||||
Min[rt] += c;
|
||||
}
|
||||
inline void pushDown(int rt)
|
||||
{
|
||||
modify(rt << 1, add[rt]);
|
||||
modify((rt << 1) | 1, add[rt]);
|
||||
add[rt] = 0;
|
||||
}
|
||||
void build(int l, int r, int rt)
|
||||
{
|
||||
add[rt] = 0;
|
||||
if (l == r) {
|
||||
Max[rt] = Min[rt] = a[l];
|
||||
return ;
|
||||
}
|
||||
int m = (l + r) >> 1;
|
||||
build(l, m, rt << 1);
|
||||
build(m + 1, r, (rt << 1) | 1);
|
||||
pushUp(rt);
|
||||
}
|
||||
void update(int l, int r, int rt, LL L, LL R, LL D)
|
||||
{
|
||||
if (L > Max[rt] || R < Min[rt]) return ;
|
||||
if (L <= Min[rt] && R >= Max[rt]) {
|
||||
modify(rt, D);
|
||||
return ;
|
||||
}
|
||||
if (l == r) return ;
|
||||
int m = (l + r) >> 1;
|
||||
pushDown(rt);
|
||||
update(l, m, rt << 1, L, R, D);
|
||||
update(m + 1, r, (rt << 1) | 1, L, R, D);
|
||||
pushUp(rt);
|
||||
}
|
||||
int query(int l, int r, int rt, LL L, LL R)
|
||||
{
|
||||
if (L > Max[rt] || R < Min[rt]) {
|
||||
return 0;
|
||||
}
|
||||
if (L <= Min[rt] && R >= Max[rt]) {
|
||||
return r - l + 1;
|
||||
}
|
||||
if (l == r) return 0;
|
||||
int m = (l + r) >> 1;
|
||||
pushDown(rt);
|
||||
return query(l, m, rt << 1, L, R) + query(m + 1, r, (rt << 1) | 1, L, R);
|
||||
}
|
||||
void getNewArr(int l, int r, int rt)
|
||||
{
|
||||
if (l == r) {
|
||||
a[l] = Max[rt];
|
||||
return ;
|
||||
}
|
||||
int m = (l + r) >> 1;
|
||||
pushDown(rt);
|
||||
getNewArr(l, m, rt << 1);
|
||||
getNewArr(m + 1, r, (rt << 1) | 1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
using namespace ST;
|
||||
int n, m;
|
||||
char op[2];
|
||||
long long L, R, D;
|
||||
while (scanf("%d%d", &n, &m) != EOF) {
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
scanf("%lld", &a[i]);
|
||||
}
|
||||
sort(a + 1, a + n + 1);
|
||||
build(1, n, 1);
|
||||
while (m--) {
|
||||
scanf("%s", op);
|
||||
if (op[0] == 'C') {
|
||||
scanf("%lld%lld%lld", &L, &R, &D);
|
||||
update(1, n, 1, L, R, D);
|
||||
} else {
|
||||
scanf("%lld%lld", &L, &R);
|
||||
printf("%d\n", query(1, n, 1, L, R));
|
||||
}
|
||||
if (m % 4500 == 0) {
|
||||
getNewArr(1, n, 1);
|
||||
sort(a + 1, a + n + 1);
|
||||
build(1, n, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#define maxn 100010
|
||||
#define p 33
|
||||
using namespace std;
|
||||
typedef unsigned long long ll;
|
||||
struct Tree{
|
||||
int l,r;
|
||||
ll hashes;
|
||||
}tree[300000];
|
||||
char str[2000100];
|
||||
ll hh[maxn];
|
||||
void init(){
|
||||
int i;
|
||||
hh[0]=1;
|
||||
for(i=1;i<=maxn;i++)
|
||||
hh[i]=hh[i-1]*p;
|
||||
}
|
||||
ll calhash(){
|
||||
int i,len=strlen(str);
|
||||
ll sum=0;
|
||||
for(i=0;i<len;i++)
|
||||
sum=sum*p+str[i]-'a'+1;
|
||||
return sum;
|
||||
}
|
||||
void build(int s,int t,int id){
|
||||
tree[id].l=s;tree[id].r=t;
|
||||
if(s==t){
|
||||
tree[id].hashes=str[s]-'a'+1;
|
||||
return;
|
||||
}
|
||||
int mid=(s+t)>>1;
|
||||
build(s,mid,id<<1);
|
||||
build(mid+1,t,id<<1|1);
|
||||
tree[id].hashes=tree[id<<1].hashes*hh[t-mid]+tree[id<<1|1].hashes;
|
||||
}
|
||||
void update(int l,int id){
|
||||
if(tree[id].l==tree[id].r){
|
||||
tree[id].hashes=str[l]-'a'+1;
|
||||
return ;
|
||||
}
|
||||
int mid=(tree[id].l+tree[id].r)>>1;
|
||||
if(l<=mid) update(l,id<<1);
|
||||
else update(l,id<<1|1);
|
||||
tree[id].hashes=tree[id<<1].hashes*hh[tree[id].r-mid]+tree[id<<1|1].hashes;
|
||||
}
|
||||
ll query(int s,int t,int id){
|
||||
if(tree[id].l==s && tree[id].r==t)
|
||||
return tree[id].hashes;
|
||||
int mid=(tree[id].l+tree[id].r)>>1;
|
||||
if(t<=mid) return query(s,t,id<<1);
|
||||
else if(s>mid) return query(s,t,id<<1|1);
|
||||
return query(s,mid,id<<1)*hh[t-mid]+query(mid+1,t,id<<1|1);
|
||||
}
|
||||
int main(){
|
||||
int t,T,pos,l,r,i,q,n;
|
||||
char s1[10],s2[10];
|
||||
map<ll,int>mp;
|
||||
init();
|
||||
scanf("%d",&T);
|
||||
for(t=1;t<=T;t++){
|
||||
printf("Case #%d:\n",t);
|
||||
scanf("%d",&n);
|
||||
mp.clear();
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%s",str);
|
||||
mp.insert(make_pair(calhash(),1));
|
||||
}
|
||||
scanf("%s",str);
|
||||
int len=strlen(str);
|
||||
build(0,len-1,1);
|
||||
scanf("%d",&q);
|
||||
for(i=1;i<=q;i++){
|
||||
scanf("%s",s1);
|
||||
if(s1[0]=='C'){
|
||||
scanf("%d%s",&pos,s2);
|
||||
str[pos]=s2[0];
|
||||
update(pos,1);
|
||||
}
|
||||
else{
|
||||
scanf("%d %d",&l,&r);
|
||||
if(mp.find(query(l,r,1))!=mp.end()) printf("Yes\n");
|
||||
else printf("No\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int MAX = 50010;
|
||||
struct NODE
|
||||
{
|
||||
int task,count;
|
||||
};
|
||||
NODE p[MAX];
|
||||
int parent[MAX];
|
||||
void init()
|
||||
{
|
||||
memset(parent,-1,sizeof(parent));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncases,n,u,v,m,x,task;
|
||||
char s[5];
|
||||
scanf("%d",&ncases);
|
||||
int ind=1;
|
||||
while(ncases--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
init();
|
||||
int i;
|
||||
for(i=0;i<n-1;i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
parent[u]=v;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
p[i].task=-1;
|
||||
p[i].count=-1;
|
||||
}
|
||||
scanf("%d",&m);
|
||||
printf("Case #%d:\n",ind++);
|
||||
int count=0;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%s",s);
|
||||
if(s[0]=='T')
|
||||
{
|
||||
scanf("%d%d",&x,&task);
|
||||
p[x].task=task;
|
||||
p[x].count=++count;
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&x);
|
||||
task=p[x].task;
|
||||
int count=p[x].count;
|
||||
while(x!=-1)
|
||||
{
|
||||
if(p[x].count>count)
|
||||
{
|
||||
task=p[x].task;
|
||||
count=p[x].count;
|
||||
}
|
||||
x=parent[x];
|
||||
}
|
||||
printf("%d\n",task);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define EPS 1e-8
|
||||
int main(){
|
||||
int t,i,ca=1;
|
||||
scanf("%d",&t);
|
||||
double ti,g=10;
|
||||
double x0[3],vx[3],vy[3],d[3],v[3];
|
||||
double a,b,t1,c;
|
||||
while(t--){
|
||||
for(i=0;i<3;i++)scanf("%lf",x0+i);
|
||||
for(i=0;i<3;i++)scanf("%lf",v+i);
|
||||
for(i=0;i<3;i++)scanf("%lf",d+i);
|
||||
for(i=0;i<3;i++){
|
||||
vx[i]=v[i]*cos(d[i]);
|
||||
vy[i]=v[i]*sin(d[i]);
|
||||
if(i==0 || ti>2*vy[i]/g)
|
||||
ti=2*vy[i]/g;
|
||||
}
|
||||
a=(vx[0]-vx[1])*(vy[1]-vy[2])-((vx[1]-vx[2])*(vy[0]-vy[1]));
|
||||
b=(x0[0]-x0[1])*(vy[1]-vy[2])-(x0[1]-x0[2])*(vy[0]-vy[1]);
|
||||
printf("Case #%d: ",ca++);
|
||||
if(ti<EPS)
|
||||
printf("-1\n");
|
||||
else if(fabs(a)<EPS && fabs(b)<EPS)
|
||||
printf("Multiply answer\n");
|
||||
else if(fabs(a)<EPS)
|
||||
printf("-1\n");
|
||||
else{
|
||||
t1=-b/a;
|
||||
if(t1>EPS && ti-t1>-EPS )
|
||||
printf("%.4lf\n",t1+EPS);
|
||||
else
|
||||
printf("-1\n");
|
||||
}
|
||||
}
|
||||
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>
|
||||
using namespace std;
|
||||
const double eps = 1e-9;
|
||||
const int MAXN = 100;
|
||||
double a[MAXN][MAXN],x[MAXN];
|
||||
int equ,var;
|
||||
int Gauss()
|
||||
{
|
||||
int i,j,k,col,max_r;
|
||||
for(k = 0,col = 0;k < equ && col < var;k++,col++)
|
||||
{
|
||||
max_r = k;
|
||||
for(i = k+1;i < equ;i++)
|
||||
if(fabs(a[i][col]) > fabs(a[max_r][col]))
|
||||
max_r = i;
|
||||
if(fabs(a[max_r][col]) < eps)return 0;
|
||||
if(k != max_r)
|
||||
{
|
||||
for(j = col;j < var;j++)
|
||||
swap(a[k][j],a[max_r][j]);
|
||||
swap(x[k],x[max_r]);
|
||||
}
|
||||
x[k]/=a[k][col];
|
||||
for(j = col+1;j < var;j++)a[k][j]/=a[k][col];
|
||||
a[k][col] = 1;
|
||||
for(int i = 0;i < equ;i++)
|
||||
if(i != k)
|
||||
{
|
||||
x[i] -= x[k]*a[i][k];
|
||||
for(j = col+1;j < var;j++)a[i][j] -= a[k][j]*a[i][col];
|
||||
a[i][col] = 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int T;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d",&n,&m);
|
||||
equ = var = n;
|
||||
memset(a,0,sizeof(a));
|
||||
int u,v,w;
|
||||
for(int i = 0;i < m;i++)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
a[u-1][v-1] += 1.0/w;
|
||||
a[u-1][u-1] += -1.0/w;
|
||||
a[v-1][u-1] += 1.0/w;
|
||||
a[v-1][v-1] += -1.0/w;
|
||||
}
|
||||
for(int i = 0;i < n-1;i++)
|
||||
x[i] = 0;
|
||||
x[0] = 1;
|
||||
for(int i = 0;i < n;i++)
|
||||
a[n-1][i] = 0;
|
||||
x[n-1] = 0;
|
||||
a[n-1][0] = 1;
|
||||
Gauss();
|
||||
printf("Case #%d: %.2lf\n",iCase,x[n-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,207 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define MAXN 1000005
|
||||
int prime[MAXN];
|
||||
int p[MAXN];
|
||||
int s[MAXN];
|
||||
vector <int> pmo[MAXN];
|
||||
int up;
|
||||
int tag[MAXN];
|
||||
int ttt[MAXN];
|
||||
int answer[MAXN];
|
||||
typedef struct
|
||||
{
|
||||
long long m[2][2];
|
||||
}Matrix;
|
||||
void Prime()
|
||||
{
|
||||
long long i,k;
|
||||
up=0;
|
||||
memset(prime,0,sizeof(prime));
|
||||
for (i=2;i<=MAXN-3;i++)
|
||||
{
|
||||
if (prime[i]==1) continue;
|
||||
k=i;
|
||||
while(k*i<MAXN-2)
|
||||
{
|
||||
prime[i*k]=1;
|
||||
k++;
|
||||
}
|
||||
p[up++]=i;
|
||||
prime[i]=up-1;
|
||||
}
|
||||
}
|
||||
Matrix Mul(Matrix a,Matrix b,int mod)
|
||||
{
|
||||
Matrix c;
|
||||
int i,j,k;
|
||||
for (i=0;i<2;i++)
|
||||
{
|
||||
for (j=0;j<2;j++)
|
||||
{
|
||||
c.m[i][j]=0;
|
||||
for (k=0;k<2;k++)
|
||||
{
|
||||
c.m[i][j]=(c.m[i][j]+a.m[i][k]*b.m[k][j])%mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
long long CountFib(int t,int mod)
|
||||
{
|
||||
Matrix a,b;
|
||||
int k=t;
|
||||
a.m[0][0]=a.m[0][1]=a.m[1][0]=b.m[0][0]=1;
|
||||
a.m[1][1]=b.m[1][0]=b.m[0][1]=b.m[1][1]=0;
|
||||
while(t)
|
||||
{
|
||||
if (t&1)
|
||||
{
|
||||
b=Mul(a,b,mod);
|
||||
}
|
||||
a=Mul(a,a,mod);
|
||||
t>>=1;
|
||||
}
|
||||
return b.m[0][0];
|
||||
}
|
||||
int num[100][2];
|
||||
int ret;
|
||||
int now=0;
|
||||
int Multi(int t,int n)
|
||||
{
|
||||
int ans=1;
|
||||
while(n)
|
||||
{
|
||||
if (n&1) ans=ans*t;
|
||||
t=t*t;
|
||||
n>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void DFS(int t,int mod,int mul)
|
||||
{
|
||||
int j;
|
||||
if (mul>=ret) return;
|
||||
if (t==now)
|
||||
{
|
||||
if (CountFib(mul,mod)==1 && CountFib(mul+1,mod)==1) ret=mul;
|
||||
return;
|
||||
}
|
||||
for (j=0;j<=num[t][1];j++)
|
||||
{
|
||||
if (num[t][0]==2 && j==0) continue;
|
||||
int k=mul*Multi(num[t][0],j);
|
||||
DFS(t+1,mod,k);
|
||||
}
|
||||
}
|
||||
int DT(int t,int mod)
|
||||
{
|
||||
int i;
|
||||
ret=t;
|
||||
now=0;
|
||||
for (i=0;i<up;i++)
|
||||
{
|
||||
if (t%p[i]!=0) continue;
|
||||
num[now][0]=p[i];
|
||||
num[now][1]=0;
|
||||
while(t%p[i]==0)
|
||||
{
|
||||
num[now][1]++;
|
||||
t/=p[i];
|
||||
}
|
||||
now++;
|
||||
if (t==1) break;
|
||||
}
|
||||
if (t!=1)
|
||||
{
|
||||
num[now][0]=t;
|
||||
num[now++][1]=1;
|
||||
}
|
||||
DFS(0,mod,1);
|
||||
return ret;
|
||||
}
|
||||
int Count(int t)
|
||||
{
|
||||
int i,k,j;
|
||||
if (t==2)
|
||||
{
|
||||
return 3;
|
||||
}
|
||||
else if (t==5)
|
||||
{
|
||||
return 20;
|
||||
}
|
||||
if (t%10==1 || t%10==9) k=t-1;
|
||||
if (t%10==3 || t%10==7) k=t*2+2;
|
||||
return DT(k,t);
|
||||
}
|
||||
int fj[50][2];
|
||||
int main()
|
||||
{
|
||||
int i,j,m,T,cnt;
|
||||
long long n;
|
||||
Prime();
|
||||
scanf("%d",&T);
|
||||
cnt=1;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d",&n);
|
||||
m=0;
|
||||
for (i=0;i<up;i++)
|
||||
{
|
||||
if (n%p[i]==0)
|
||||
{
|
||||
fj[m][0]=p[i];
|
||||
fj[m][1]=0;
|
||||
while(n%p[i]==0)
|
||||
{
|
||||
fj[m][1]++;
|
||||
n/=p[i];
|
||||
}
|
||||
m++;
|
||||
}
|
||||
if (n==1) break;
|
||||
}
|
||||
memset(answer,0,sizeof(answer));
|
||||
int mm=0;
|
||||
for (i=0;i<m;i++)
|
||||
{
|
||||
memset(tag,0,sizeof(tag));
|
||||
if (fj[i][1]>0)
|
||||
{
|
||||
mm=max(prime[fj[i][0]],mm);
|
||||
tag[prime[fj[i][0]]]+=fj[i][1]-1;
|
||||
}
|
||||
int tt=Count(fj[i][0]);
|
||||
for (j=0;j<up;j++)
|
||||
{
|
||||
while(tt%p[j]==0)
|
||||
{
|
||||
tt/=p[j];
|
||||
tag[j]++;
|
||||
mm=max(mm,j);
|
||||
}
|
||||
if (tt==1) break;
|
||||
}
|
||||
for (j=0;j<=mm;j++)
|
||||
{
|
||||
answer[j]=max(tag[j],answer[j]);
|
||||
}
|
||||
}
|
||||
long long pr=1;
|
||||
for (i=0;i<=mm;i++)
|
||||
{
|
||||
for (j=0;j<answer[i];j++)
|
||||
{
|
||||
pr*=p[i];
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %I64d\n",cnt++,pr);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define maxn 10010
|
||||
typedef long long LL;
|
||||
int prime[maxn];
|
||||
map<LL,LL>pika;
|
||||
void Prime(){
|
||||
memset(prime,0,sizeof(prime));
|
||||
for(int i=2;i<maxn;i++){
|
||||
if(!prime[i]) prime[++prime[0]]=i;
|
||||
for(int j=1;j<=prime[0]&&prime[j]<maxn/i;j++){
|
||||
prime[prime[j]*i]=1;
|
||||
if(i%prime[j]==0){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
LL factor[100][2];
|
||||
int fatcnt;
|
||||
int get_factors(LL n){
|
||||
fatcnt=0;
|
||||
LL tmp=n;
|
||||
for(int i=1;prime[i]<=tmp/prime[i];i++){
|
||||
factor[fatcnt][1]=0;
|
||||
if(tmp%prime[i]==0){
|
||||
factor[fatcnt][0]=prime[i];
|
||||
while(tmp%prime[i]==0){
|
||||
tmp/=prime[i];
|
||||
factor[fatcnt][1]++;
|
||||
}
|
||||
fatcnt++;
|
||||
}
|
||||
}
|
||||
if(tmp!=1){
|
||||
factor[fatcnt][0]=tmp;
|
||||
factor[fatcnt][1]=1;
|
||||
fatcnt++;
|
||||
}
|
||||
return fatcnt;
|
||||
}
|
||||
LL gcd(LL a,LL b){
|
||||
if(b==0){
|
||||
return a;
|
||||
}
|
||||
else{
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
}
|
||||
LL lcm(LL a,LL b){
|
||||
return a/gcd(a,b)*b;
|
||||
}
|
||||
struct Matrix{
|
||||
LL m[2][2];
|
||||
}E,D;
|
||||
Matrix Multi(Matrix A,Matrix B,LL mod){
|
||||
Matrix ans;
|
||||
for(int i=0;i<2;i++){
|
||||
for(int j=0;j<2;j++){
|
||||
ans.m[i][j]=0;
|
||||
for(int k=0;k<2;k++){
|
||||
ans.m[i][j]+=(A.m[i][k]*B.m[k][j])%mod;
|
||||
if(ans.m[i][j]>=mod){
|
||||
ans.m[i][j]-=mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void init(){
|
||||
memset(E.m,0,sizeof(E.m));
|
||||
memset(D.m,0,sizeof(D.m));
|
||||
D.m[0][0]=D.m[0][1]=D.m[1][0]=1;
|
||||
for(int i=0;i<2;i++){
|
||||
E.m[i][i]=1;
|
||||
}
|
||||
Prime();
|
||||
}
|
||||
Matrix Pow(Matrix A,LL e,LL mod){
|
||||
Matrix ans=E;
|
||||
while(e){
|
||||
if(e&1){
|
||||
ans=Multi(ans,A,mod);
|
||||
}
|
||||
A=Multi(A,A,mod);
|
||||
e>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL Pow(LL a,LL b,LL mod){
|
||||
LL ans=1;
|
||||
while(b){
|
||||
if(b&1){
|
||||
ans=(ans*a)%mod;
|
||||
}
|
||||
a=(a*a)%mod;
|
||||
b>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int legendre(LL a,LL p){
|
||||
if(Pow(a,(p-1)>>1,p)==1){
|
||||
return 1;
|
||||
}
|
||||
else{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
int f0=1,f1=1;
|
||||
LL get_fib(LL n,LL mod)
|
||||
{
|
||||
if(mod==1) return 0;
|
||||
return Pow(D,n,mod).m[0][0]%mod;
|
||||
}
|
||||
LL fac[maxn],GG[maxn];
|
||||
LL G(LL p)
|
||||
{
|
||||
if(p<maxn && GG[p]!=-1) return GG[p];
|
||||
LL num;
|
||||
if(legendre(5,p)==1){
|
||||
num=p-1;
|
||||
}
|
||||
else{
|
||||
num=2*(p+1);
|
||||
}
|
||||
int cnt=0;
|
||||
for(LL i=1;i*i<=num;i++){
|
||||
if(num%i==0){
|
||||
fac[cnt++]=i;
|
||||
if(i*i!=num){
|
||||
fac[cnt++]=num/i;
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(fac,fac+cnt);
|
||||
LL ans;
|
||||
for(int i=0;i<cnt;i++){
|
||||
if(get_fib(fac[i],p)==f0&&get_fib(fac[i]+1,p)==f1){
|
||||
ans=fac[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(p<maxn) GG[p]=ans;
|
||||
return ans;
|
||||
}
|
||||
LL find_loop(LL n)
|
||||
{
|
||||
if(pika.count(n)){
|
||||
return pika[n];
|
||||
}
|
||||
get_factors(n);
|
||||
LL ans=1;
|
||||
for(int i=0;i<fatcnt;i++)
|
||||
{
|
||||
LL record=1;
|
||||
if(factor[i][0]==2) record=3;
|
||||
else if(factor[i][0]==3) record=8;
|
||||
else if(factor[i][0]==5) record=20;
|
||||
else record=G(factor[i][0]);
|
||||
for(int j=1;j<factor[i][1];j++)
|
||||
record*=factor[i][0];
|
||||
ans=lcm(ans,record);
|
||||
}
|
||||
return pika[n]=ans;
|
||||
}
|
||||
LL loop[10010];
|
||||
void solve(LL p,LL k){
|
||||
loop[0]=p;
|
||||
for(int i=1;i<=k;i++){
|
||||
loop[i]=find_loop(loop[i-1]);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
pika.clear();
|
||||
init();
|
||||
memset(GG,-1,sizeof(GG));
|
||||
int T,cas=0;
|
||||
scanf("%d",&T);
|
||||
LL n,p,k;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d",&n,&k,&p);
|
||||
solve(p,k);
|
||||
for(int i=k;i>=0;i--){
|
||||
n=get_fib(n,loop[i]);
|
||||
}
|
||||
printf("Case #%d: %I64d\n",++cas,n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#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>
|
||||
using namespace std;
|
||||
struct Node
|
||||
{
|
||||
int h,g;
|
||||
}node[10010];
|
||||
int n,m;
|
||||
bool cmp(Node a,Node b)
|
||||
{
|
||||
return a.h*b.g < b.h*a.g;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase ++;
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%d%d",&node[i].h,&node[i].g);
|
||||
node[i].h = (node[i].h + m - 1)/m;
|
||||
}
|
||||
sort(node,node+n,cmp);
|
||||
long long ans = 0;
|
||||
int cnt = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
cnt += node[i].h;
|
||||
ans += (long long)cnt*node[i].g;
|
||||
}
|
||||
printf("Case #%d: %I64d\n",iCase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int t, n, m;
|
||||
int f[1005];
|
||||
bool emerge[1000];
|
||||
int get_sg(int len)
|
||||
{
|
||||
if(len<m) return f[len]=0;
|
||||
if(f[len]!=-1) return f[len];
|
||||
bool vs[1001]={0};
|
||||
for(int i=0; len-i-m>=0; i++)
|
||||
vs[get_sg(i)^get_sg(len-i-m)]=1;
|
||||
for(int i=0; i<1001; i++)
|
||||
if(!vs[i]) return f[len]=i;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &t);
|
||||
for(int ca=1; ca<=t; ca++)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
memset(f, -1, sizeof(f));
|
||||
printf("Case #%d: ", ca);
|
||||
if(n<m || get_sg(n-m)) printf("abcdxyzk\n");
|
||||
else printf("aekdycoin\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define forn(i, n) for(int i = 0; i < (int)(n); i++)
|
||||
#define clr(a, b) memset(a, b, sizeof(a))
|
||||
#define SZ(a) ((int)a.size())
|
||||
#define PB push_back
|
||||
#define MP make_pair
|
||||
#define inf 0x3f3f3f3f
|
||||
typedef vector<int> vi;
|
||||
typedef pair<int, int> pii;
|
||||
typedef long long ll;
|
||||
#ifdef ecust
|
||||
#define RR "%lld"
|
||||
#else
|
||||
#define RR "%I64d"
|
||||
#endif
|
||||
namespace acm {
|
||||
int dp[2][220][10][220];
|
||||
int T, HS, A, R, U, D, FI, P;
|
||||
int des[300];
|
||||
void update(int &a, int b) {
|
||||
a = max(a, b);
|
||||
}
|
||||
void solve() {
|
||||
scanf("%d%d%d%d", &T, &HS, &A, &R);
|
||||
scanf("%d%d%d%d", &U, &D, &FI, &P);
|
||||
forn(i, T)
|
||||
scanf("%d", des + i + 1);
|
||||
clr(dp, 0x3f);
|
||||
forn(i, 2)
|
||||
forn(j, 220)
|
||||
forn(k, 10)
|
||||
forn(l, 220)
|
||||
dp[i][j][k][l] = -inf;
|
||||
int now = 0;
|
||||
dp[0][HS][0][0] = 0;
|
||||
for (int tt = 1; tt <= T; ++tt) {
|
||||
int fang = des[tt];
|
||||
for (int i = 1; i <= HS; ++i) {
|
||||
for (int j = 0; j <= 6; ++j) {
|
||||
for (int k = 0; k <= T; ++k) {
|
||||
if (dp[now][i][j][k] == -inf)
|
||||
continue;
|
||||
if (i > D) {
|
||||
int add = A + (HS - i) / R * U;
|
||||
if (add < fang)
|
||||
add = 0;
|
||||
else
|
||||
add -= fang;
|
||||
update(dp[now ^ 1][i - D][6][k + 1], dp[now][i][j][k]
|
||||
+ add + FI * k);
|
||||
}
|
||||
int add = A + (HS - i) / R * U;
|
||||
if (add < fang)
|
||||
add = 0;
|
||||
else
|
||||
add -= fang;
|
||||
if (j - 1 == 0)
|
||||
update(dp[now ^ 1][i][j - 1][0], dp[now][i][j][k] + add
|
||||
+ FI * k);
|
||||
else if (j)
|
||||
update(dp[now ^ 1][i][j - 1][k], dp[now][i][j][k] + add
|
||||
+ FI * k);
|
||||
else if (j == 0)
|
||||
update(dp[now ^ 1][i][j][k], dp[now][i][j][k] + add);
|
||||
}
|
||||
}
|
||||
}
|
||||
now = now ^ 1;
|
||||
}
|
||||
int ans = -inf, ans2 = -inf;
|
||||
forn(j, 220)
|
||||
forn(k, 10)
|
||||
forn(l, 220) {
|
||||
if (dp[now ][j][k][l] != inf) {
|
||||
update(ans, dp[now ][j][k][l] - (HS - j) * P);
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
void icpc() {
|
||||
int nc, nn = 1;
|
||||
scanf("%d", &nc);
|
||||
while (nc--) {
|
||||
printf("Case #%d: ", nn++);
|
||||
solve();
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
acm::icpc();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,267 @@
|
|||
#include <set>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#define MID(x,y) ( ( x + y ) >> 1 )
|
||||
#define L(x) ( x << 1 )
|
||||
#define R(x) ( x << 1 | 1 )
|
||||
#define FOR(i,s,t) for(int i=s; i<t; i++)
|
||||
#define BUG puts("here!!!")
|
||||
using namespace std;
|
||||
const int MAX = 2010;
|
||||
struct point {
|
||||
double x,y;
|
||||
void P(double xx, double yy){ x = xx; y = yy;}
|
||||
void get(){ scanf("%lf%lf",&x, &y);}
|
||||
};
|
||||
struct line { point a,b; double ang;};
|
||||
point s[MAX*2], ch, p[MAX*2];
|
||||
line l[MAX*2],deq[MAX*2];
|
||||
const double eps = 1e-6;
|
||||
const double pi = acos(-1.0);
|
||||
bool dy(double x,double y) { return x > y + eps;}
|
||||
bool xy(double x,double y) { return x < y - eps;}
|
||||
bool dyd(double x,double y) { return x > y - eps;}
|
||||
bool xyd(double x,double y) { return x < y + eps;}
|
||||
bool dd(double x,double y) { return fabs( x - y ) < eps;}
|
||||
double crossProduct(point a,point b,point c)
|
||||
{
|
||||
return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);
|
||||
}
|
||||
double disp2p(point a,point b)
|
||||
{
|
||||
return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
|
||||
}
|
||||
bool parallel(line u,line v)
|
||||
{
|
||||
return dd( (u.a.x - u.b.x)*(v.a.y - v.b.y) - (v.a.x - v.b.x)*(u.a.y - u.b.y) , 0.0 );
|
||||
}
|
||||
point l2l_inst_p(line l1,line l2)
|
||||
{
|
||||
point ans = l1.a;
|
||||
double t = ((l1.a.x - l2.a.x)*(l2.a.y - l2.b.y) - (l1.a.y - l2.a.y)*(l2.a.x - l2.b.x))/
|
||||
((l1.a.x - l1.b.x)*(l2.a.y - l2.b.y) - (l1.a.y - l1.b.y)*(l2.a.x - l2.b.x));
|
||||
ans.x += (l1.b.x - l1.a.x)*t;
|
||||
ans.y += (l1.b.y - l1.a.y)*t;
|
||||
return ans;
|
||||
}
|
||||
bool equal_ang(line a,line b)
|
||||
{
|
||||
return dd(a.ang,b.ang);
|
||||
}
|
||||
bool cmphp(line a,line b)
|
||||
{
|
||||
if( dd(a.ang,b.ang) ) return xy(crossProduct(b.a,b.b,a.a),0.0);
|
||||
return xy(a.ang,b.ang);
|
||||
}
|
||||
bool equal_p(point a,point b)
|
||||
{
|
||||
return dd(a.x,b.x) && dd(a.y,b.y);
|
||||
}
|
||||
void makeline_hp(double x1,double y1,double x2,double y2,line &l)
|
||||
{
|
||||
l.a.x = x1; l.a.y = y1; l.b.x = x2; l.b.y = y2;
|
||||
l.ang = atan2(y2 - y1,x2 - x1);
|
||||
}
|
||||
void inst_hp_nlogn(line *ln,int n,point *s,int &len)
|
||||
{
|
||||
len = 0;
|
||||
sort(ln,ln+n,cmphp);
|
||||
n = unique(ln,ln+n,equal_ang) - ln;
|
||||
int bot = 0,top = 1;
|
||||
deq[0] = ln[0]; deq[1] = ln[1];
|
||||
for(int i=2; i<n; i++)
|
||||
{
|
||||
if( parallel(deq[top],deq[top-1]) || parallel(deq[bot],deq[bot+1]) )
|
||||
return ;
|
||||
while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,
|
||||
l2l_inst_p(deq[top],deq[top-1])),0.0) )
|
||||
top--;
|
||||
while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,
|
||||
l2l_inst_p(deq[bot],deq[bot+1])),0.0) )
|
||||
bot++;
|
||||
deq[++top] = ln[i];
|
||||
}
|
||||
while( bot < top && dy(crossProduct(deq[bot].a,deq[bot].b,
|
||||
l2l_inst_p(deq[top],deq[top-1])),0.0) ) top--;
|
||||
while( bot < top && dy(crossProduct(deq[top].a,deq[top].b,
|
||||
l2l_inst_p(deq[bot],deq[bot+1])),0.0) ) bot++;
|
||||
if( top <= bot + 1 ) return ;
|
||||
for(int i=bot; i<top; i++)
|
||||
s[len++] = l2l_inst_p(deq[i],deq[i+1]);
|
||||
if( bot < top + 1 ) s[len++] = l2l_inst_p(deq[bot],deq[top]);
|
||||
len = unique(s,s+len,equal_p) - s;
|
||||
}
|
||||
point l2l_inst_p(point u1,point u2,point v1,point v2)
|
||||
{
|
||||
point ans = u1;
|
||||
double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
|
||||
((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
|
||||
ans.x += (u2.x - u1.x)*t;
|
||||
ans.y += (u2.y - u1.y)*t;
|
||||
return ans;
|
||||
}
|
||||
void l2c_inst_p(point c,double r,point l1,point l2,point &p1,point &p2)
|
||||
{
|
||||
point p = c;
|
||||
double t;
|
||||
p.x += l1.y - l2.y;
|
||||
p.y += l2.x - l1.x;
|
||||
p = l2l_inst_p(p,c,l1,l2);
|
||||
t = sqrt(r*r - disp2p(p,c)*disp2p(p,c))/disp2p(l1,l2);
|
||||
p1.x = p.x + (l2.x - l1.x)*t;
|
||||
p1.y = p.y + (l2.y - l1.y)*t;
|
||||
p2.x = p.x - (l2.x - l1.x)*t;
|
||||
p2.y = p.y - (l2.y - l1.y)*t;
|
||||
}
|
||||
double disp2l(point a,point l1,point l2)
|
||||
{
|
||||
return fabs( crossProduct(a,l1,l2) )/disp2p(l1,l2);
|
||||
}
|
||||
bool onSegment(point a, point b, point c)
|
||||
{
|
||||
if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,min(a.x,b.x)) &&
|
||||
xyd(c.x,max(a.x,b.x)) && dyd(c.y,min(a.y,b.y)) && xyd(c.y,max(a.y,b.y)) )
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
bool cmp(point a,point b)
|
||||
{
|
||||
double t1 = atan2(a.y - ch.y, a.x - ch.x);
|
||||
double t2 = atan2(b.y - ch.y, b.x - ch.x);
|
||||
return xy(t1, t2);
|
||||
}
|
||||
double area_triangle(point a,point b,point c)
|
||||
{
|
||||
return fabs( crossProduct(a,b,c) )/2.0;
|
||||
}
|
||||
double gong_area(point c,point a,point b,double r)
|
||||
{
|
||||
if( dd(crossProduct(c,a,b), 0.0) )
|
||||
return r*r*pi/2;
|
||||
double area = area_triangle(a, b, c);
|
||||
double ang = acos(1-disp2p(a,b)*disp2p(a,b)/(r*r*2));
|
||||
return ang*r*r/2 - area;
|
||||
}
|
||||
bool incircle(point a,point c, double r)
|
||||
{
|
||||
return xy(disp2p(a, c), r);
|
||||
}
|
||||
bool pin_convexh(point *p,int n,point a)
|
||||
{
|
||||
p[n] = p[0]; p[n+1] = p[1];
|
||||
for(int i=0; i<n; i++)
|
||||
if( xy(crossProduct(p[i],p[i+1],a)*
|
||||
crossProduct(p[i+1],p[i+2],a),0.0) )
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
point foot_line(point a,point l1,point l2)
|
||||
{
|
||||
point c;
|
||||
c.x = a.x - l2.y + l1.y;
|
||||
c.y = a.y + l2.x - l1.x;
|
||||
return c;
|
||||
}
|
||||
double solve(point *s, int len, double r)
|
||||
{
|
||||
point c; c.x = c.y = 0;
|
||||
point a, b;
|
||||
int cnt = 0;
|
||||
s[len] = s[0];
|
||||
FOR(i, 0, len)
|
||||
{
|
||||
if( xy(disp2l(c, s[i], s[i+1]), r) )
|
||||
{
|
||||
l2c_inst_p(c, r, s[i], s[i+1], a, b);
|
||||
if( onSegment(s[i], s[i+1], a) )
|
||||
p[cnt++] = a;
|
||||
if( onSegment(s[i], s[i+1], b) )
|
||||
p[cnt++] = b;
|
||||
}
|
||||
if( incircle(s[i], c, r) )
|
||||
p[cnt++] = s[i];
|
||||
if( incircle(s[i+1], c, r) )
|
||||
p[cnt++] = s[i+1];
|
||||
}
|
||||
sort(p, p+cnt, cmp);
|
||||
cnt = unique(p, p+cnt, equal_p) - p;
|
||||
p[cnt] = p[0];
|
||||
double area = 0.0;
|
||||
if( cnt == 2 )
|
||||
{
|
||||
if( xy(crossProduct(p[0],p[1],ch), 0.0) )
|
||||
swap(p[0], p[1]);
|
||||
cnt--;
|
||||
}
|
||||
FOR(i, 0, cnt)
|
||||
{
|
||||
area += area_triangle(p[0], p[i], p[i+1]);
|
||||
if( !dd(disp2p(p[i], c), r) || !dd(disp2p(p[i+1], c), r) )
|
||||
continue;
|
||||
point mid;
|
||||
mid.P((p[i].x + p[i+1].x)/2, (p[i].y + p[i+1].y)/2);
|
||||
point a, b, k;
|
||||
k = foot_line(c, p[i], p[i+1]);
|
||||
l2c_inst_p(c, r, k, c, a, b);
|
||||
bool flag = false;
|
||||
if( dyd(crossProduct(p[i], p[i+1], a), 0.0) && pin_convexh(s, len, a) )
|
||||
flag = true;
|
||||
if( dyd(crossProduct(p[i], p[i+1], b), 0.0) && pin_convexh(s, len, b) )
|
||||
flag = true;
|
||||
if( !flag ) continue;
|
||||
double area_gong = gong_area(c, p[i], p[i+1], r);
|
||||
if( dy(crossProduct(p[i], p[i+1], c), 0.0) )
|
||||
area_gong = pi*r*r - area_gong;
|
||||
area += area_gong;
|
||||
}
|
||||
return area/(pi*r*r);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncases, ind = 1, n;
|
||||
double r;
|
||||
scanf("%d", &ncases);
|
||||
while( ncases-- )
|
||||
{
|
||||
scanf("%lf%d",&r, &n);
|
||||
FOR(i, 0, n)
|
||||
{
|
||||
l[i].a.get();
|
||||
l[i].b.get();
|
||||
}
|
||||
ch.get();
|
||||
bool f = false;
|
||||
point c; c.P(0,0);
|
||||
FOR(i, 0, n)
|
||||
{
|
||||
if( dy(crossProduct(l[i].a, l[i].b, ch), 0.0) )
|
||||
swap(l[i].a, l[i].b);
|
||||
l[i].ang = atan2(l[i].b.y - l[i].a.y, l[i].b.x - l[i].a.x);
|
||||
if( xy(disp2l(c,l[i].a, l[i].b), r) )
|
||||
f = true;
|
||||
}
|
||||
if( !f )
|
||||
{
|
||||
printf("Case %d: %.5lf%%\n",ind++, 100.0);
|
||||
continue;
|
||||
}
|
||||
makeline_hp(-2*r, -2*r, 2*r, -2*r, l[n++]);
|
||||
makeline_hp(2*r, -2*r, 2*r, 2*r, l[n++]);
|
||||
makeline_hp(2*r, 2*r, -2*r, 2*r, l[n++]);
|
||||
makeline_hp(-2*r, 2*r, -2*r, -2*r, l[n++]);
|
||||
int len;
|
||||
inst_hp_nlogn(l, n, s, len);
|
||||
double ans = solve(s, len, r);
|
||||
printf("Case %d: %.5lf%%\n",ind++, ans*100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
const int MAXN=1000+10;
|
||||
const int inf=1<<30;
|
||||
struct Node{
|
||||
int v,w,id;
|
||||
};
|
||||
vector<Node>vet[MAXN];
|
||||
int path[MAXN];
|
||||
int dist[MAXN];
|
||||
bool visited[MAXN];
|
||||
bool mark[MAXN*50];
|
||||
int id[MAXN];
|
||||
int n,m;
|
||||
bool tag;
|
||||
void SPFA(int u){
|
||||
for(int i=1;i<=n;i++)dist[i]=inf;
|
||||
dist[u]=0;
|
||||
memset(visited,false,sizeof(visited));
|
||||
queue<int>Q;
|
||||
Q.push(u);
|
||||
while(!Q.empty()){
|
||||
int u=Q.front();
|
||||
Q.pop();
|
||||
visited[u]=false;
|
||||
for(int i=0;i<vet[u].size();i++){
|
||||
int v=vet[u][i].v;
|
||||
int w=vet[u][i].w;
|
||||
int ID=vet[u][i].id;
|
||||
if(mark[vet[u][i].id])continue;
|
||||
if(dist[u]+w<dist[v]){
|
||||
dist[v]=dist[u]+w;
|
||||
if(tag)path[v]=u,id[v]=ID;
|
||||
if(!visited[v]){
|
||||
Q.push(v);
|
||||
visited[v]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int _case;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=1;i<=n;i++)vet[i].clear();
|
||||
memset(path,-1,sizeof(path));
|
||||
memset(mark,false,sizeof(mark));
|
||||
for(int i=1;i<=m;i++){
|
||||
int u,v,w;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
Node p1,p2;
|
||||
p1.v=u,p2.v=v;
|
||||
p1.w=p2.w=w;
|
||||
p1.id=p2.id=i;
|
||||
vet[u].push_back(p2);
|
||||
vet[v].push_back(p1);
|
||||
}
|
||||
tag=true;
|
||||
SPFA(1);
|
||||
tag=false;
|
||||
if(dist[n]==inf){
|
||||
printf("-1\n");
|
||||
continue;
|
||||
}
|
||||
int ans=0;
|
||||
bool flag=true;
|
||||
for(int u=n;u!=-1;u=path[u]){
|
||||
mark[id[u]]=true;
|
||||
SPFA(1);
|
||||
mark[id[u]]=false;
|
||||
if(dist[n]==inf){
|
||||
printf("-1\n");
|
||||
flag=false;
|
||||
break;
|
||||
}
|
||||
ans=max(ans,dist[n]);
|
||||
}
|
||||
if(flag){
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define MAXN 2222
|
||||
#define MAXM 2222222
|
||||
struct Edge{
|
||||
int v,next;
|
||||
ll cap;
|
||||
}edge[MAXM];
|
||||
int head[MAXN];
|
||||
int pre[MAXN];
|
||||
int cur[MAXN];
|
||||
int level[MAXN];
|
||||
int gap[MAXN];
|
||||
int NV,NE,n,m,vs,vt;
|
||||
void Insert(int u,int v,ll cap,ll cc=0){
|
||||
edge[NE].v=v;edge[NE].cap=cap;
|
||||
edge[NE].next=head[u];head[u]=NE++;
|
||||
edge[NE].v=u;edge[NE].cap=cc;
|
||||
edge[NE].next=head[v];head[v]=NE++;
|
||||
}
|
||||
ll SAP(int vs,int vt){
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(level,0,sizeof(level));
|
||||
memset(gap,0,sizeof(gap));
|
||||
for(int i=0;i<=NV;i++)cur[i]=head[i];
|
||||
int u=pre[vs]=vs;
|
||||
ll aug=-1,maxflow=0;
|
||||
gap[0]=NV;
|
||||
while(level[vs]<NV){
|
||||
loop:
|
||||
for(int &i=cur[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&level[u]==level[v]+1){
|
||||
aug==-1?aug=edge[i].cap:aug=min(aug,edge[i].cap);
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==vt){
|
||||
maxflow+=aug;
|
||||
for(u=pre[u];v!=vs;v=u,u=pre[u]){
|
||||
edge[cur[u]].cap-=aug;
|
||||
edge[cur[u]^1].cap+=aug;
|
||||
}
|
||||
aug=-1;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
int minlevel=NV;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&minlevel>level[v]){
|
||||
cur[u]=i;
|
||||
minlevel=level[v];
|
||||
}
|
||||
}
|
||||
if(--gap[level[u]]==0)break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
int main(){
|
||||
int _case,u,v,w,flag,t=1;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
vs=0,vt=n-1,NV=n,NE=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
for(int i=1;i<=m;i++){
|
||||
scanf("%d%d%d%d",&u,&v,&w,&flag);
|
||||
Insert(u,v,(ll)w*MAXM+1);
|
||||
if(flag)Insert(v,u,(ll)w*MAXM+1);
|
||||
}
|
||||
ll ans=SAP(vs,vt);
|
||||
printf("Case %d: %d\n",t++,ans%MAXM);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#define N 100005
|
||||
#define MOD 9973
|
||||
#define LL unsigned long long
|
||||
#define eps 1e-7
|
||||
#define zero(a) fabs(a)<eps
|
||||
#define equal(a,b) zero(a-b)
|
||||
using namespace std;
|
||||
bool flag[10000005];
|
||||
int cnt=0,prime[10000005];
|
||||
void Init(){
|
||||
for(int i=2;i<=sqrt(10000000.0)+1;i++){
|
||||
if(flag[i])
|
||||
continue;
|
||||
for(int j=2;j*i<=10000000;j++)
|
||||
flag[i*j]=true;
|
||||
}
|
||||
for(int i=2;i<=10000000;i++)
|
||||
if(!flag[i])
|
||||
prime[cnt++]=i;
|
||||
}
|
||||
LL get_sum(LL n,LL p){
|
||||
LL ret=0;
|
||||
while(n){
|
||||
n/=p;
|
||||
ret+=n;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
int t,cas=0;
|
||||
scanf("%d",&t);
|
||||
Init();
|
||||
while(t--){
|
||||
LL n,k;
|
||||
scanf("%I64u%I64u",&n,&k);
|
||||
if(k==1){
|
||||
printf("Case %d: inf\n",++cas);
|
||||
continue;
|
||||
}
|
||||
LL mmax=-1;
|
||||
for(int i=0;i<cnt&&prime[i]<=k;i++){
|
||||
if(k%prime[i]==0){
|
||||
int c=0;
|
||||
while(k%prime[i]==0){
|
||||
c++;
|
||||
k/=prime[i];
|
||||
}
|
||||
LL tmp=get_sum(n,prime[i])/c;
|
||||
if(mmax==-1)
|
||||
mmax=tmp;
|
||||
else
|
||||
mmax=min(mmax,tmp);
|
||||
}
|
||||
}
|
||||
if(k>1){
|
||||
LL tmp=get_sum(n,k);
|
||||
if(mmax==-1)
|
||||
mmax=tmp;
|
||||
else
|
||||
mmax=min(mmax,tmp);
|
||||
}
|
||||
printf("Case %d: %I64u\n",++cas,mmax);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
struct EDGE
|
||||
{
|
||||
int v, next;
|
||||
}edge[2010010];
|
||||
struct NODE
|
||||
{
|
||||
int p;
|
||||
long long t;
|
||||
}node[1010];
|
||||
const long long inf = 1ll<<60;
|
||||
long long map[105][105];
|
||||
bool usedif[1005];
|
||||
int link[1005];
|
||||
int head[1010];
|
||||
int cnt, gx, gy;
|
||||
bool cmp(NODE a, NODE b)
|
||||
{
|
||||
return a.t < b.t;
|
||||
}
|
||||
void addedge(int u, int v)
|
||||
{
|
||||
edge[cnt].v = v;
|
||||
edge[cnt].next = head[u];
|
||||
head[u] = cnt++;
|
||||
}
|
||||
bool can(int t)
|
||||
{
|
||||
for(int p = head[t]; p != -1; p = edge[p].next)
|
||||
{
|
||||
int i = edge[p].v;
|
||||
if(usedif[i]==0)
|
||||
{
|
||||
usedif[i]=1;
|
||||
if(link[i]==-1||can(link[i]))
|
||||
{
|
||||
link[i]=t;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int MaxMatch()
|
||||
{
|
||||
int num=0;
|
||||
memset(link,-1,sizeof(link));
|
||||
for(int i=0; i< gx; i++)
|
||||
{
|
||||
memset(usedif,0,sizeof(usedif));
|
||||
if(can(i)) num++;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
int cas = 1;
|
||||
while(T--)
|
||||
{
|
||||
int n, m, q;
|
||||
scanf("%d%d%d", &n, &m, &q);
|
||||
int d = 1<< 30;
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
if(i != j) map[i][j] = inf;
|
||||
else map[i][j] = 0;
|
||||
while(m--)
|
||||
{
|
||||
int a, b;
|
||||
long long c;
|
||||
scanf("%d%d%I64d", &a, &b, &c);
|
||||
if(map[a][b] > c)
|
||||
{
|
||||
map[a][b] = map[b][a] = c;
|
||||
}
|
||||
}
|
||||
for(int k = 0; k < n; k++)
|
||||
for(int i = 0; i < n; i++)
|
||||
{
|
||||
if(i == k) continue;
|
||||
if(map[i][k] == inf) continue;
|
||||
for(int j = 0; j < n; j++)
|
||||
if(map[k][j] != inf && map[i][k] + map[k][j] < map[i][j])
|
||||
{
|
||||
map[i][j] = map[i][k] + map[k][j];
|
||||
}
|
||||
}
|
||||
for(int i = 0; i < q; i++)
|
||||
{
|
||||
scanf("%d%d", &node[i].p, &node[i].t);
|
||||
}
|
||||
gx = q;
|
||||
cnt = 0;
|
||||
memset(head, -1, sizeof(head));
|
||||
for(int i = 0; i < q; i++)
|
||||
{
|
||||
for(int j = 0; j < q; j++)
|
||||
if(i != j && node[j].t - node[i].t >= map[node[i].p][node[j].p])
|
||||
{
|
||||
addedge(i, j);
|
||||
}
|
||||
}
|
||||
int ans = gx - MaxMatch();
|
||||
printf("Case %d: %d\n", cas++, ans - 1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,190 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn=100000;
|
||||
struct Node
|
||||
{
|
||||
int flag;
|
||||
int id;
|
||||
Node* next[26];
|
||||
Node* fail;
|
||||
};
|
||||
Node* root;
|
||||
Node temp[maxn];
|
||||
int tp;
|
||||
void reset(Node* p)
|
||||
{
|
||||
p->flag=0;p->id=tp-1;
|
||||
for(int i=0;i<26;i++) p->next[i]=NULL;
|
||||
p->fail=root;
|
||||
if(p==root) p->fail=NULL;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
tp=0;
|
||||
root=&temp[tp++];
|
||||
reset(root);
|
||||
}
|
||||
void insert(char* str)
|
||||
{
|
||||
Node* p=root;
|
||||
for(int i=0;str[i];i++)
|
||||
{
|
||||
int x=str[i]-'a';
|
||||
if(p->next[x]==NULL)
|
||||
{
|
||||
p->next[x]=&temp[tp++];
|
||||
reset(p->next[x]);
|
||||
}
|
||||
p=p->next[x];
|
||||
}
|
||||
p->flag=1;
|
||||
}
|
||||
Node* que[maxn];
|
||||
int front,rear;
|
||||
void DFA()
|
||||
{
|
||||
front=rear=0;
|
||||
que[rear++]=root;
|
||||
while(front<rear)
|
||||
{
|
||||
Node* t=que[front++];
|
||||
for(int i=0;i<26;i++)
|
||||
{
|
||||
Node* cnt=t->next[i];
|
||||
if(cnt!=NULL)
|
||||
{
|
||||
Node* fath=t->fail;
|
||||
while(fath!=NULL&&fath->next[i]==NULL)
|
||||
{
|
||||
fath=fath->fail;
|
||||
}
|
||||
if(fath==NULL)
|
||||
{
|
||||
cnt->fail=root;
|
||||
}
|
||||
else cnt->fail=fath->next[i];
|
||||
cnt->flag|=cnt->fail->flag;
|
||||
que[rear++]=cnt;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
double pet[26];
|
||||
int n;
|
||||
char str[maxn];
|
||||
double a[1000][1000];
|
||||
int equ,var;//浠0寮濮
|
||||
void toMatrix()
|
||||
{
|
||||
var=rear;
|
||||
equ=0;
|
||||
memset(a,0,sizeof(a));
|
||||
for(int i=0;i<rear;i++)
|
||||
{
|
||||
Node* p=&temp[i];
|
||||
if(p->flag)
|
||||
{
|
||||
a[equ][p->id]=1;
|
||||
a[equ++][var]=0;
|
||||
continue;
|
||||
}
|
||||
a[equ][p->id]=-1;
|
||||
a[equ][var]=-1;
|
||||
for(int j=0;j<26;j++)
|
||||
{
|
||||
Node* cnt=p->next[j];
|
||||
int k;
|
||||
if(cnt!=NULL)
|
||||
{
|
||||
k=cnt->id;
|
||||
a[equ][k]+=pet[j];
|
||||
}
|
||||
else
|
||||
{
|
||||
Node* fath=p->fail;
|
||||
while(fath!=NULL&&fath->next[j]==NULL)
|
||||
{
|
||||
fath=fath->fail;
|
||||
}
|
||||
if(fath!=NULL)
|
||||
{
|
||||
k=fath->next[j]->id;
|
||||
a[equ][k]+=pet[j];
|
||||
}
|
||||
else
|
||||
{
|
||||
k=0;
|
||||
a[equ][0]+=pet[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
equ++;
|
||||
}
|
||||
}
|
||||
const double eps=1e-10;
|
||||
double x[1000];
|
||||
void Gauss()
|
||||
{
|
||||
for(int i=0;i<equ;i++)
|
||||
{
|
||||
int j;
|
||||
for(j=i;j<equ;j++)
|
||||
{
|
||||
if(fabs(a[j][i])>eps) break;
|
||||
}
|
||||
for(int k=i;k<=var;k++) swap(a[i][k],a[j][k]);
|
||||
for(j=i+1;j<equ;j++)
|
||||
{
|
||||
double p=-a[j][i]/a[i][i];
|
||||
for(int k=i;k<=var;k++) a[j][k]+=a[i][k]*p;
|
||||
}
|
||||
}
|
||||
for(int i=equ-1;i>=0;i--)
|
||||
{
|
||||
x[i]=a[i][var]/a[i][i];
|
||||
a[i][var]/=a[i][i];a[i][i]=1;
|
||||
for(int j=i-1;j>=0;j--)
|
||||
{
|
||||
a[j][var]+=-a[j][i]*a[i][var];
|
||||
a[j][i]=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n)==1)
|
||||
{
|
||||
init();
|
||||
for(int i=0;i<26;i++) scanf("%lf",&pet[i]);
|
||||
int flag=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",str);
|
||||
insert(str);
|
||||
int f=1;
|
||||
for(int j=0;str[j];j++)
|
||||
{
|
||||
int x=str[j]-'a';
|
||||
if(fabs(pet[x])<eps)
|
||||
{
|
||||
f=0;break;
|
||||
}
|
||||
}
|
||||
if(f) flag=1;
|
||||
}
|
||||
if(!flag)
|
||||
{
|
||||
printf("Infinity\n");
|
||||
continue;
|
||||
}
|
||||
DFA();
|
||||
toMatrix();
|
||||
Gauss();
|
||||
printf("%.6lf\n",x[0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int a[20];
|
||||
int b[20];
|
||||
int main(){
|
||||
int test,n;
|
||||
scanf("%d",&test);
|
||||
while (test--){
|
||||
scanf("%d",&n);
|
||||
for (int i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
for (int j=0;j<n;j++)
|
||||
scanf("%d",&b[j]);
|
||||
int ans=0;
|
||||
for (int i=0;i<n;i++)
|
||||
for (int j=0;j<n;j++)
|
||||
if (b[i]>a[j]) ans+=3;
|
||||
printf("%.6lf\n",ans*1.0/n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MaxN 200
|
||||
#define eps 1e-8
|
||||
double dp[MaxN+5][MaxN+5];
|
||||
double tmp[MaxN+5][MaxN+5];
|
||||
int n;
|
||||
int c;
|
||||
int m;
|
||||
int lst[MaxN+5];
|
||||
void floyd(bool flag){
|
||||
int i,j,k;
|
||||
if (flag){
|
||||
for (k=0;k<n;k++){
|
||||
for (i=0;i<n;i++){
|
||||
for (j=0;j<n;j++){
|
||||
if ((i==j) || (j==k) || (i==k)) continue;
|
||||
if (dp[i][j]<dp[i][k]*dp[k][j]){
|
||||
dp[i][j]=dp[i][k]*dp[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
for (k=0;k<n;k++){
|
||||
for (i=0;i<n;i++){
|
||||
for (j=0;j<n;j++){
|
||||
if ((i==j) || (j==k) || (i==k)) continue;
|
||||
if (dp[i][k]>=0 && dp[k][j]>=0 && (dp[i][j]<0 || dp[i][j]>dp[i][k]+dp[k][j])){
|
||||
dp[i][j]=dp[i][k]+dp[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool iszero(double a)
|
||||
{
|
||||
return a<eps;
|
||||
}
|
||||
void init(){
|
||||
int i,j;
|
||||
scanf("%d",&n);
|
||||
for (i=0;i<n;i++){
|
||||
for (j=0;j<n;j++){
|
||||
scanf("%lf",&dp[i][j]);
|
||||
dp[i][j]=dp[i][j]/100.0;
|
||||
}
|
||||
}
|
||||
floyd(1);
|
||||
scanf("%d",&m);
|
||||
for (i=0;i<m;i++){
|
||||
scanf("%d",&lst[i]);
|
||||
}
|
||||
for (i=0;i<m;i++){
|
||||
if (lst[i]==1) break;
|
||||
}
|
||||
if (i==m) lst[m++]=1;
|
||||
for (i=0;i<m;i++){
|
||||
if (lst[i]==2) break;
|
||||
}
|
||||
if (i==m) lst[m++]=2;
|
||||
sort(lst,lst+m);
|
||||
for (i=0;i<m;i++){
|
||||
for (j=i+1;j<m;j++){
|
||||
tmp[i][j]=dp[lst[i]-1][lst[j]-1];
|
||||
tmp[j][i]=dp[lst[j]-1][lst[i]-1];
|
||||
}
|
||||
}
|
||||
for (i=0;i<m;i++){
|
||||
for (j=0;j<m;j++){
|
||||
if (iszero(tmp[i][j]))dp[i][j]=-1;
|
||||
else dp[i][j]=1.0/tmp[i][j];
|
||||
if (iszero(tmp[j][i]))dp[j][i]=-1;
|
||||
else dp[j][i]=1.0/tmp[j][i];
|
||||
}
|
||||
}
|
||||
n=m;
|
||||
scanf("%d",&c);
|
||||
floyd(0);
|
||||
}
|
||||
void solve(){
|
||||
printf("%.6lf\n",dp[0][1]*c);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while (t--){
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
#define sqr(a) ((a)*(a))
|
||||
#define trarea(p) fabs ((vdet(p[0],p[1],p[2])/2.0))
|
||||
double const EPS = 1e-12;
|
||||
int const maxn = 20011;
|
||||
struct point{double x,y;int flag;};
|
||||
struct circle{
|
||||
point c;
|
||||
double r;
|
||||
};
|
||||
inline double vdet(point op,point p1,point p2){
|
||||
return (p1.x-op.x)*(p2.y-op.y)-(p2.x-op.x)*(p1.y-op.y);
|
||||
}
|
||||
inline double dis(point a,point b){
|
||||
return sqr(a.x-b.x)+sqr(a.y-b.y);
|
||||
}
|
||||
inline point get_out_circle(point p[]){
|
||||
double c1,c2,xa,xb,xc,ya,yb,yc;
|
||||
point o;
|
||||
xa=p[0].x,xb=p[1].x,xc=p[2].x;
|
||||
ya = p[0].y,yb = p[1].y,yc = p[2].y;
|
||||
c1 = (sqr(xa) + sqr(ya) - sqr(xb) - sqr(yb))/2.0;
|
||||
c2 = (sqr(xa) + sqr(ya) - sqr(xc) - sqr(yc))/2.0;
|
||||
o.x = (c1*(ya-yc)-c2*(ya-yb))/((xa-xb)*(ya-yc)-(xa-xc)*(ya-yb));
|
||||
o.y = (c1*(xa-xc)-c2*(xa-xb))/((ya-yb)*(xa-xc)-(ya-yc)*(xa-xb));
|
||||
return o;
|
||||
}
|
||||
inline double get_out_r(point p[]){
|
||||
double a = dis(p[0],p[1]),b = dis(p[1],p[2]),c = dis(p[2],p[0]),s = trarea(p);
|
||||
return a*b*c/sqr(4*s);
|
||||
}
|
||||
point must_on[3],p[maxn];
|
||||
circle mc;
|
||||
inline void get_circle(int tm){
|
||||
switch(tm){
|
||||
case 0:mc.r = -1;
|
||||
break;
|
||||
case 1:mc.r = 0,mc.c = must_on[0];
|
||||
break;
|
||||
case 2:{
|
||||
mc.r = dis(must_on[0],must_on[1])/4.0;
|
||||
mc.c.x = (must_on[0].x+must_on[1].x)/2.0;
|
||||
mc.c.y = (must_on[0].y + must_on[1].y)/2.0;
|
||||
}break;
|
||||
case 3:{
|
||||
mc.r = get_out_r(must_on);
|
||||
mc.c = get_out_circle(must_on);
|
||||
}break;
|
||||
}
|
||||
}
|
||||
inline void min_circle(int t,int ton){
|
||||
get_circle(ton);
|
||||
if(ton >= 3)return;
|
||||
for(int i = 0; i < t; ++i){
|
||||
if(p[i].flag == 1){
|
||||
if(dis(mc.c,p[i]) > mc.r + EPS){
|
||||
must_on[ton] = p[i];
|
||||
min_circle(i,ton+1);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if(dis(mc.c,p[i]) + EPS < mc.r){
|
||||
must_on[ton] = p[i];
|
||||
min_circle(i,ton+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int n,m;
|
||||
while (scanf("%d%d",&n,&m) != EOF){
|
||||
for(int i = 0; i < n; ++i){
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
p[i].flag = 1;
|
||||
}
|
||||
for(int i = n; i < m + n; ++i){
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
p[i].flag = 2;
|
||||
}
|
||||
n = n + m;
|
||||
random_shuffle(p,p+n);
|
||||
min_circle(n,0);
|
||||
printf("%.3lf %.3lf\n%.3lf\n",mc.c.x,mc.c.y,sqrt(mc.r));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=62002;
|
||||
const int M=62002;
|
||||
const __int64 INF=1LL<<60;
|
||||
int t,n,m,tot,cas=1;
|
||||
int gap[M],dis[M],pre[M],head[N],cur[N],vis[N];
|
||||
int NE,NV,sink,source;
|
||||
struct Node
|
||||
{
|
||||
__int64 c;
|
||||
int pos,next;
|
||||
} E[9999999];
|
||||
#define FF(i,NV) for(int i=0;i<NV;i++)
|
||||
__int64 sap(int s,int t)
|
||||
{
|
||||
memset(dis,0,sizeof(int)*(NV+1));
|
||||
memset(gap,0,sizeof(int)*(NV+1));
|
||||
FF(i,NV) cur[i] = head[i];
|
||||
int u = pre[s] = s;
|
||||
__int64 maxflow = 0,aug =INF;
|
||||
gap[0] = NV;
|
||||
while(dis[s] < NV)
|
||||
{
|
||||
loop:
|
||||
for(int &i = cur[u]; i != -1; i = E[i].next)
|
||||
{
|
||||
int v = E[i].pos;
|
||||
if(E[i].c && dis[u] == dis[v] + 1)
|
||||
{
|
||||
if(aug>E[i].c) aug=E[i].c;
|
||||
pre[v] = u;
|
||||
u = v;
|
||||
if(v == t)
|
||||
{
|
||||
maxflow += aug;
|
||||
for(u = pre[u]; v != s; v = u,u = pre[u])
|
||||
{
|
||||
E[cur[u]].c -= aug;
|
||||
E[cur[u]^1].c += aug;
|
||||
}
|
||||
aug =INF;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
if( (--gap[dis[u]]) == 0) break;
|
||||
int mindis = NV;
|
||||
for(int i = head[u]; i != -1 ; i = E[i].next)
|
||||
{
|
||||
int v = E[i].pos;
|
||||
if(E[i].c >0&& mindis > dis[v])
|
||||
{
|
||||
cur[u] = i;
|
||||
mindis = dis[v];
|
||||
}
|
||||
}
|
||||
gap[ dis[u] = mindis+1 ] ++;
|
||||
u = pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
void addEdge(int u,int v,__int64 c )
|
||||
{
|
||||
E[NE].c = c;
|
||||
E[NE].pos = v;
|
||||
E[NE].next = head[u];
|
||||
head[u] = NE++;
|
||||
E[NE].c = 0;
|
||||
E[NE].pos = u;
|
||||
E[NE].next = head[v];
|
||||
head[v] = NE++;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
int i,j,a,b,w,cost,val;
|
||||
__int64 sum=0;
|
||||
source=0,sink=3000,NE=0,NV=sink+1;
|
||||
memset(head,-1,sizeof(int)*(NV));
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
scanf("%d",&m);
|
||||
for(int j=1; j<=m; j++)
|
||||
{
|
||||
scanf("%d%d%d",&cost,&val,&w);
|
||||
val-=cost;
|
||||
if(val>0)
|
||||
{
|
||||
addEdge(source,i*26+j,val);
|
||||
sum+=val;
|
||||
}
|
||||
else addEdge(i*26+j,sink,-val);
|
||||
while(w--)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
addEdge(i*26+j,a*26+b,INF);
|
||||
}
|
||||
}
|
||||
}
|
||||
__int64 ans=sap(source,sink);
|
||||
printf("Case #%d: %I64d\n",cas++,sum-ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std ;
|
||||
const int INF=0xfffffff ;
|
||||
struct node
|
||||
{
|
||||
int s,t,cap,nxt ;
|
||||
}e[400005] ;
|
||||
int m,n,cnt,head[100005],level[100005],q[100005] ;
|
||||
void add(int s,int t,int cap)
|
||||
{
|
||||
e[cnt].s=s ;e[cnt].t=t ;e[cnt].cap=cap ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;
|
||||
e[cnt].s=t ;e[cnt].t=s ;e[cnt].cap=0 ;e[cnt].nxt=head[t] ;head[t]=cnt++ ;
|
||||
}
|
||||
bool build(int s,int t)
|
||||
{
|
||||
int front=0,rear=0 ;
|
||||
memset(level,-1,sizeof(level)) ;
|
||||
q[rear++]=s ;
|
||||
level[s]=1 ;
|
||||
while(front<rear)
|
||||
{
|
||||
int u=q[front++] ;
|
||||
for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
|
||||
{
|
||||
int tt=e[i].t ;
|
||||
if(level[tt]==-1 && e[i].cap>0)
|
||||
{
|
||||
level[tt]=level[u]+1 ;
|
||||
if(tt==t)return true ;
|
||||
q[rear++]=tt ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false ;
|
||||
}
|
||||
int find(int s,int t,int flow)
|
||||
{
|
||||
if(s==t)return flow ;
|
||||
int ret=0,a ;
|
||||
for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
|
||||
{
|
||||
int tt=e[i].t ;
|
||||
if(level[tt]==level[s]+1 && e[i].cap>0)
|
||||
{
|
||||
a=find(tt,t,min(e[i].cap,flow-ret)) ;
|
||||
e[i].cap-=a ;
|
||||
e[i^1].cap+=a ;
|
||||
ret+=a ;
|
||||
if(ret==flow)
|
||||
return ret ;
|
||||
}
|
||||
}
|
||||
if(!ret)level[s]=-1 ;
|
||||
return ret ;
|
||||
}
|
||||
int dinic(int s,int t)
|
||||
{
|
||||
int flow,ret=0 ;
|
||||
while(build(s,t))
|
||||
while(flow=find(s,t,INF))
|
||||
ret+=flow ;
|
||||
return ret ;
|
||||
}
|
||||
int a[1005],dp[1005] ;
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(int i=1 ;i<=n ;i++)
|
||||
scanf("%d",&a[i]) ;
|
||||
int ans=0 ;
|
||||
for(int i=1 ;i<=n ;i++)
|
||||
{
|
||||
dp[i]=1 ;
|
||||
for(int j=1 ;j<i ;j++)
|
||||
if(a[j]<a[i] && dp[j]+1>dp[i])
|
||||
dp[i]=dp[j]+1 ;
|
||||
ans=max(ans,dp[i]) ;
|
||||
}
|
||||
int S,T ;
|
||||
S=0 ;T=2*n+1 ;
|
||||
cnt=0 ;
|
||||
memset(head,-1,sizeof(head)) ;
|
||||
for(int i=1 ;i<=n ;i++)
|
||||
{
|
||||
add(i,i+n,1) ;
|
||||
if(dp[i]==1)add(S,i,1) ;
|
||||
if(dp[i]==ans)add(i+n,T,1) ;
|
||||
for(int j=i+1 ;j<=n ;j++)
|
||||
{
|
||||
if(dp[j]==dp[i]+1)
|
||||
add(i+n,j,1) ;
|
||||
}
|
||||
}
|
||||
printf("%d\n%d\n",ans,dinic(S,T)) ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
struct node{
|
||||
int num;
|
||||
struct node *left;
|
||||
struct node *right;
|
||||
}*tree;
|
||||
int tot=0;
|
||||
node *build(node *root,int num)
|
||||
{
|
||||
if(root==NULL)
|
||||
{
|
||||
root=new node;
|
||||
root->left=NULL;
|
||||
root->right=NULL;
|
||||
root->num=num;
|
||||
return root;
|
||||
}
|
||||
else
|
||||
{
|
||||
int t=root->num-num;;
|
||||
if(t>0)
|
||||
root->left=build(root->left,num);
|
||||
else
|
||||
root->right=build(root->right,num);
|
||||
return root;
|
||||
}
|
||||
}
|
||||
bool first;
|
||||
void visit(node *root)
|
||||
{
|
||||
if(root!=NULL&&!first)
|
||||
printf(" %d",root->num);
|
||||
else
|
||||
{
|
||||
first=false;
|
||||
printf("%d",root->num);
|
||||
}
|
||||
}
|
||||
void preorder(node *root)
|
||||
{
|
||||
if(root!=NULL)
|
||||
{
|
||||
visit(root);
|
||||
preorder(root->left);
|
||||
preorder(root->right);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,num;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
first=true;
|
||||
int num;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&num);
|
||||
tree=build(tree,num);
|
||||
}
|
||||
preorder(tree);
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue