目录
1371: Maximum Shortest Distance
1411: Longest Consecutive Ones
1424: Qz’s Maximum All One Square
1436: Revenge of the Round Table
1551: Longest Increasing Subsequence Again
1302: Walking on Chessboard
#include<iostream>
#include<stdio.h>
#include<cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<string.h>
#define ll long long
#define oo 1000007
#define pi acos(-1.0)
#define MAXN 500005
using namespace std;
struct node
{
int x,y,k;
}h,p;
int m,n,k,ex,ey,num[105][105][1005];
bool used[105][105][1005];
queue<node> myqueue;
int main()
{
while (~scanf("%d%d%d%d%d%d%d",&n,&m,&h.x,&h.y,&ex,&ey,&k))
{
while (!myqueue.empty()) myqueue.pop();
h.k=0;
myqueue.push(h);
memset(num,0,sizeof(num));
memset(used,false,sizeof(used));
used[h.y][h.x][0]=true;
num[h.y][h.x][0]=1;
while (!myqueue.empty())
{
h=myqueue.front();
myqueue.pop();
if (h.k==k) continue;
if (h.y+1<=m)
{
p.x=h.x,p.y=h.y+1,p.k=h.k+1;
if (!used[p.y][p.x][p.k]) myqueue.push(p),used[p.y][p.x][p.k]=true;
num[p.y][p.x][p.k]=(num[p.y][p.x][p.k]+num[h.y][h.x][h.k])%oo;
}
if (h.x-1>=1)
{
p.x=h.x-1,p.y=h.y,p.k=h.k+1;
if (!used[p.y][p.x][p.k]) myqueue.push(p),used[p.y][p.x][p.k]=true;
num[p.y][p.x][p.k]=(num[p.y][p.x][p.k]+num[h.y][h.x][h.k])%oo;
}
if (h.x+1<=n)
{
p.x=h.x+1,p.y=h.y,p.k=h.k+1;
if (!used[p.y][p.x][p.k]) myqueue.push(p),used[p.y][p.x][p.k]=true;
num[p.y][p.x][p.k]=(num[p.y][p.x][p.k]+num[h.y][h.x][h.k])%oo;
}
}
printf("%d\n",num[ey][ex][k]);
}
return 0;
}1303: Decimal
#include <iostream>
#include <stdio.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <set>
#include <algorithm>
#include <map>
#define Max(a,b) ((a)>(b)?(a):(b))
using namespace std ;
typedef long long LL ;
LL gcd(LL x ,LL y){
return y==0?x:gcd(y,x%y) ;
}
LL my_pow(LL x ,int y){
LL sum=1 ;
for(;y;y>>=1){
if(y&1)
sum*=x ;
x*=x ;
}
return sum ;
}
int main(){
int x ,y ,L_a ,L_b;
string str ,A ,B;
LL fenzi ,fenmu;
LL ab ,a ;
while(cin>>str){
for(int i=0;i<str.length();i++){
if(str[i]=='(')
x=i ;
}
A="" ;
B="" ;
A=str.substr(2,x-2) ;
B=str.substr(x+1,str.length()-x-2) ;
L_a=A.length() ;
L_b=B.length() ;
ab=a=0 ;
for(int i=0;i<A.length();i++){
ab=ab*10+A[i]-'0' ;
}
for(int i=0;i<B.length();i++){
ab=ab*10+B[i]-'0' ;
}
for(int i=0;i<A.length();i++){
a=a*10+A[i]-'0' ;
}
if(B==""){
fenzi=a ;
fenmu=my_pow((LL)10,L_a) ;
}
else{
fenzi=ab-a ;
fenmu=my_pow((LL)10,L_a+L_b)-my_pow((LL)10,L_a) ;
}
LL temp=gcd(fenzi,fenmu) ;
fenzi/=temp ;
fenmu/=temp ;
cout<<fenzi<<"/"<<fenmu<<endl ;
}
return 0 ;
}1306: Manor
#include <stdio.h>
#include <queue>
#include <algorithm>
using namespace std;
struct node
{
int l,r;
bool operator<(node Q) const//先按右边元素取最小，相同则左边取最大
{
if (Q.r!=r) return Q.r<r;
return l<Q.l;
}
} mon;
priority_queue<node> Q;
int ans[2005];
int main()
{
int n,k,a,b,x,i,j;
while(~scanf("%d%d%d%d",&n,&k,&a,&b))
{
while(!Q.empty())//清空
Q.pop();
int len = 0;
for(i = 1; i<=n; i++)
{
scanf("%d",&x);
if(x<=k)
{
mon.l = x;//放入A
mon.r = 0;//B没有
Q.push(mon);
}
else
len++;//B里的元素
}
for(i = 1; i<=205; i++)
{
ans[i] = len;//每次操作前B内的个数
if(len>0)//B里还有
{
mon.l = 0;//往A里放0
mon.r = i-1;//第几次
Q.push(mon);//压入队列
len--;//B个数减1
}
while(!Q.empty())//队列不空
{
mon = Q.top();
if(mon.l+(i-mon.r)*a<=k)//A内最大的都小于等于k则跳出
break;
Q.pop();//否则丢入B
len++;//B个数加1
}
}
int cnt;
scanf("%d",&cnt);
while(cnt--)
{
scanf("%d",&x);
printf("%d\n",ans[x]);
}
}
return 0;
}
1307: City Tour
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define MAXN 2020
#define MAXM 55000
#define INF 0x3f3f3f3f
using namespace std;
struct node
{
int x, y, v;
}w[MAXM * 2];
int f[MAXN], n, m, s, t, maxE;
int dis[MAXN], map[MAXN][MAXN], vis[MAXN];
int cmp(node a, node b)
{
return a.v < b.v;
}
int find(int x)
{
return f[x] == x ? x : (f[x] = find(f[x]));
}
int cal()
{
int me = 0;
for(int i = 1; i <= n; i++) f[i] = i;
sort(w, w + m, cmp);
for(int i = 0; i < m; i++)
{
int x = find(w[i].x);
int y = find(w[i].y);
if(x != y)
{
f[x] = y;
me = max(me, w[i].v);
if(find(s) == find(t))
{
return me;
}
}
}
return me;
}
int dijkstra()
{
memset(vis, 0, sizeof(vis));
memset(dis, 0x3f, sizeof(dis));
for(int i = 1; i <= n; i++)
{
if(map[s][i] > maxE) continue;
dis[i] = map[s][i];
}
vis[s] = 1;
dis[s] = 0;
while(true)
{
int k = -1, mixv = INF;
for(int i = 1; i <= n; i++)
{
if(!vis[i] && mixv > dis[i])
{
k = i;
mixv = dis[i];
}
}
if(k == -1) break;
vis[k] = 1;
for(int i = 1; i <= n; i++)
{
if(!vis[i] && (dis[i] > dis[k] + map[k][i]) && map[k][i] <= maxE)
{
dis[i] = dis[k] + map[k][i];
}
}
}
/*for(int i = 1; i <= n; i++)
{
printf("%d ", dis[i]);
}
printf("\n");*/
return dis[t];
}
int main()
{
while(scanf("%d%d%d%d", &n, &m, &s, &t) != EOF)
{
memset(map, 0x3f, sizeof(map));
for(int i = 0; i < m; i++)
{
scanf("%d%d%d", &w[i].x, &w[i].y, &w[i].v);
if(w[i].v < map[w[i].x][w[i].y])
map[w[i].x][w[i].y] = map[w[i].y][w[i].x] = w[i].v;
}
maxE = cal();
//printf("%d\n", maxE);
printf("%d\n", dijkstra());
}
return 0;
}1309: 凹凸曼和小怪兽的故事
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn = 100000 + 10;
const double INF = 1000000000 * 2.0;
struct Node {
double x;
double y;
bool type;//0超人，1怪兽
}node[maxn],node2[maxn];
int n;
double Min(double a,double b)
{
return a > b ? b : a;
}
double Count(Node a,Node b)
{
return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}
double cmpX(Node a,Node b)
{
return a.x < b.x;
}
double cmpY(Node a,Node b)
{
return a.y < b.y;
}
double Clost(int begin,int end)
{
if(begin + 1 == end && node[begin].type != node[end].type)
{
return Count(node[begin],node[end]);
}
else if(node[begin].type == node[end].type)
{
return INF;
}
if(begin + 2 == end)
{
int ans1 = INF;
int ans2 = INF;
int ans3 = INF;
if(node[begin].type != node[end].type)
{
ans1 = Count(node[begin],node[end]);
}
if(node[begin+1].type != node[end].type)
{
ans2 = Count(node[begin+1],node[end]);
}
if(node[begin].type != node[begin+1].type)
{
ans3 = Count(node[begin],node[begin+1]);
}
return Min(ans1,Min(ans2,ans3));
}
int mid = (begin + end) / 2;
double ans = Min(Clost(begin,mid),Clost(mid+1,end));
int i;
int cnt = 0;
for(i=begin; i<=end; i++)
{
if(node[i].x >= node[mid].x - ans && node[i].x <= node[mid].x + ans)
{
node2[cnt++] = node[i];
}
}
sort(node2,node2+cnt,cmpY);
int j;
for(i=0; i<cnt; i++)
{
for(j=i+1; j<cnt; j++)
{
if(node2[j].y - node2[i].y >= ans)
{
break;
}
if(node2[j].type != node2[i].type)
{
ans = Min(ans,Count(node2[i],node2[j]));
}
}
}
return ans;
}
int main()
{
int a;
int b;
while(scanf("%d%d%d",&n,&a,&b) != EOF)
{
int i;
for(i=0; i<n; i++)
{
scanf("%lf%lf",&node[i].x,&node[i].y);
node[i].type = 0;
}
for(i=n; i<2*n; i++)
{
scanf("%lf%lf",&node[i].x,&node[i].y);
node[i].type = 1;
}
sort(node,node+n,cmpX);
double ans = Clost(0,2*n-1);
printf("%.3lf\n",ans/abs(a+b));
}
return 0;
}1315: 全场最水题之陈兴老师与比赛
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
struct node
{
int num;
int t;
} ans[30];
int cmp(node x,node y)//先按时间，在按序数
{
if(x.t !=y.t)
return x.t<y.t;
return x.num<y.num;
}
int main()
{
int n,i,j,sum,k;
while(~scanf("%d",&n))
{
for(i = 0; i<n; i++)
{
scanf("%d",&ans[i].t);
ans[i].num = i+1;
}
sort(ans,ans+n,cmp);
sum = 0;
k = 0;
for(i = 0; i<n; i++)
{
if(k+ans[i].t>300)//总时间大于300则跳出
break;
k+=ans[i].t;
}
int f = i,tem = i;
for(i = 0; i<f; i++)//计算罚时
{
sum += ans[i].t*tem--;
}
printf("%d %d\n",f,sum);
for(i = 0; i<f; i++)
{
printf("%d\n",ans[i].num);
}
}
return 0;
}1317: Find the max Link
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
#define maxn 50011
#define INF -10000000
struct Node {
long long son;
long long w;
};
long long ans;
vector<Node> num[maxn];
long long d[maxn][2];
void DFS(long long x,long long p)
{
long long i,v;
d[x][0]=d[x][1]=INF;
for(i=0;i<num[x].size();i++)
{
v=num[x][i].son;
if(v!=p)
{
DFS(v,x);
if(d[v][0]>0)
{
if(d[x][0]<num[x][i].w+d[v][0])
{
d[x][1]=d[x][0];
d[x][0]=num[x][i].w+d[v][0];
}
else if(d[x][1]<num[x][i].w+d[v][0])
d[x][1]=num[x][i].w+d[v][0];
}
else
{
if(d[x][0]<num[x][i].w)
{
d[x][1]=d[x][0];
d[x][0]=num[x][i].w;
}
else if(d[x][1]<num[x][i].w)
d[x][1]=num[x][i].w;
}
}
}
ans=max(ans,d[x][0]);
ans=max(ans,d[x][0]+d[x][1]);
}
int main()
{
long long N,M;
long long i,u,v;
long long w;
Node tmp;
while(scanf("%lld%lld",&N,&M)==2)
{
for(i=1;i<=N;i++)
num[i].clear();
ans=-10000000;
for(i=1;i<=M;i++)
{
scanf("%lld%lld%lld",&u,&v,&w);
tmp.w=w;
tmp.son=v; num[u].push_back(tmp);
tmp.son=u; num[v].push_back(tmp);
ans=max(ans,w);
}
DFS(1,-1);
printf("%lld\n",ans);
}
return 0;
}
/**********************************************************************
Problem: 1317
User: 3901140225
Language: C++
Result: AC
Time:104 ms
Memory:5900 kb
**********************************************************************/
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
#define maxn 50011
#define INF -10000000
struct Node {
long long son;
long long w;
};
long long ans;
vector<Node> num[maxn];
long long d[maxn][2];
void DFS(long long x,long long p)
{
long long i,v;
d[x][0]=d[x][1]=INF;
for(i=0;i<num[x].size();i++)
{
v=num[x][i].son;
if(v!=p)
{
DFS(v,x);
if(d[v][0]>0)
{
if(d[x][0]<num[x][i].w+d[v][0])
{
d[x][1]=d[x][0];
d[x][0]=num[x][i].w+d[v][0];
}
else if(d[x][1]<num[x][i].w+d[v][0])
d[x][1]=num[x][i].w+d[v][0];
}
else
{
if(d[x][0]<num[x][i].w)
{
d[x][1]=d[x][0];
d[x][0]=num[x][i].w;
}
else if(d[x][1]<num[x][i].w)
d[x][1]=num[x][i].w;
}
}
}
ans=max(ans,d[x][0]);
ans=max(ans,d[x][0]+d[x][1]);
}
int main()
{
long long N,M;
long long i,u,v;
long long w;
Node tmp;
while(scanf("%lld%lld",&N,&M)==2)
{
for(i=1;i<=N;i++)
num[i].clear();
ans=-10000000;
for(i=1;i<=M;i++)
{
scanf("%lld%lld%lld",&u,&v,&w);
tmp.w=w;
tmp.son=v; num[u].push_back(tmp);
tmp.son=u; num[v].push_back(tmp);
ans=max(ans,w);
}
DFS(1,-1);
printf("%lld\n",ans);
}
return 0;
}1319: CX‘s dreams
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
//点标 [0,n]
typedef long long ll;
const int N = 3010;
const int M = 500010;
const ll INF = 1e18;
template<class T>
struct Max_Flow {
int n;
int Q[N], sign;
int head[N], level[N], cur[N], pre[N];
int nxt[M], pnt[M], E;
T cap[M];
void Init(int n) {
this->n = n+1;
E = 0;
std::fill(head, head + this->n, -1);
}
//有向rw 就= 0
void add(int from, int to, T c, T rw) {
pnt[E] = to;
cap[E] = c;
nxt[E] = head[from];
head[from] = E++;
pnt[E] = from;
cap[E] = rw;
nxt[E] = head[to];
head[to] = E++;
}
bool Bfs(int s, int t) {
sign = t;
std::fill(level, level + n, -1);
int *front = Q, *tail = Q;
*tail++ = t; level[t] = 0;
while(front < tail && level[s] == -1) {
int u = *front++;
for(int e = head[u]; e != -1; e = nxt[e]) {
if(cap[e ^ 1] > 0 && level[pnt[e]] < 0) {
level[pnt[e]] = level[u] + 1;
*tail ++ = pnt[e];
}
}
}
return level[s] != -1;
}
void Push(int t, T &flow) {
T mi = INF;
int p = pre[t];
for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
mi = std::min(mi, cap[p]);
}
for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
cap[p] -= mi;
if(!cap[p]) {
sign = pnt[p ^ 1];
}
cap[p ^ 1] += mi;
}
flow += mi;
}
void Dfs(int u, int t, T &flow) {
if(u == t) {
Push(t, flow);
return ;
}
for(int &e = cur[u]; e != -1; e = nxt[e]) {
if(cap[e] > 0 && level[u] - 1 == level[pnt[e]]) {
pre[pnt[e]] = e;
Dfs(pnt[e], t, flow);
if(level[sign] > level[u]) {
return ;
}
sign = t;
}
}
}
T Dinic(int s, int t) {
pre[s] = -1;
T flow = 0;
while(Bfs(s, t)) {
std::copy(head, head + n, cur);
Dfs(s, t, flow);
}
return flow;
}
};
Max_Flow <ll>F;
ll dream[N], work[N], ans;
int from, to;
int n, m;
const ll C = 1e6;
void input(){
ans = 0;
from = 0; to = n+m+1;
F.Init(to);
for(int i = 1; i <= n; i++)
{
scanf("%lld", &dream[i]);
F.add(from, i, dream[i]*C+1LL, 0);
ans += dream[i];
}
for(int i = 1; i <= m; i++)
{
scanf("%lld", &work[i]);
if(work[i] >= 0) ans += work[i];
else
F.add(n +i, to, -work[i]*C, 0);
}
for(int i = 1, siz, u; i <= n; i++)
{
scanf("%d", &siz);
while(siz--){
scanf("%d", &u);
if(work[u] >= 0)continue;
F.add(i, n+u, INF, 0);
}
}
}
int main() {
while(~scanf("%d %d", &n, &m)){
input();
ll flow = F.Dinic(from,to);
// cout<<"FLOW:"<<flow<<endl;
cout<< ans - flow / C << " " << n-flow % C <<endl;
}
return 0;
}
/**********************************************************************
Problem: 1319
User: 3901140225
Language: C++
Result: AC
Time:200 ms
Memory:9940 kb
**********************************************************************/
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
//点标 [0,n]
typedef long long ll;
const int N = 3010;
const int M = 500010;
const ll INF = 1e18;
template<class T>
struct Max_Flow {
int n;
int Q[N], sign;
int head[N], level[N], cur[N], pre[N];
int nxt[M], pnt[M], E;
T cap[M];
void Init(int n) {
this->n = n+1;
E = 0;
std::fill(head, head + this->n, -1);
}
//有向rw 就= 0
void add(int from, int to, T c, T rw) {
pnt[E] = to;
cap[E] = c;
nxt[E] = head[from];
head[from] = E++;
pnt[E] = from;
cap[E] = rw;
nxt[E] = head[to];
head[to] = E++;
}
bool Bfs(int s, int t) {
sign = t;
std::fill(level, level + n, -1);
int *front = Q, *tail = Q;
*tail++ = t; level[t] = 0;
while(front < tail && level[s] == -1) {
int u = *front++;
for(int e = head[u]; e != -1; e = nxt[e]) {
if(cap[e ^ 1] > 0 && level[pnt[e]] < 0) {
level[pnt[e]] = level[u] + 1;
*tail ++ = pnt[e];
}
}
}
return level[s] != -1;
}
void Push(int t, T &flow) {
T mi = INF;
int p = pre[t];
for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
mi = std::min(mi, cap[p]);
}
for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
cap[p] -= mi;
if(!cap[p]) {
sign = pnt[p ^ 1];
}
cap[p ^ 1] += mi;
}
flow += mi;
}
void Dfs(int u, int t, T &flow) {
if(u == t) {
Push(t, flow);
return ;
}
for(int &e = cur[u]; e != -1; e = nxt[e]) {
if(cap[e] > 0 && level[u] - 1 == level[pnt[e]]) {
pre[pnt[e]] = e;
Dfs(pnt[e], t, flow);
if(level[sign] > level[u]) {
return ;
}
sign = t;
}
}
}
T Dinic(int s, int t) {
pre[s] = -1;
T flow = 0;
while(Bfs(s, t)) {
std::copy(head, head + n, cur);
Dfs(s, t, flow);
}
return flow;
}
};
Max_Flow <ll>F;
ll dream[N], work[N], ans;
int from, to;
int n, m;
const ll C = 1e6;
void input(){
ans = 0;
from = 0; to = n+m+1;
F.Init(to);
for(int i = 1; i <= n; i++)
{
scanf("%lld", &dream[i]);
F.add(from, i, dream[i]*C+1LL, 0);
ans += dream[i];
}
for(int i = 1; i <= m; i++)
{
scanf("%lld", &work[i]);
if(work[i] >= 0) ans += work[i];
else
F.add(n +i, to, -work[i]*C, 0);
}
for(int i = 1, siz, u; i <= n; i++)
{
scanf("%d", &siz);
while(siz--){
scanf("%d", &u);
if(work[u] >= 0)continue;
F.add(i, n+u, INF, 0);
}
}
}
int main() {
while(~scanf("%d %d", &n, &m)){
input();
ll flow = F.Dinic(from,to);
// cout<<"FLOW:"<<flow<<endl;
cout<< ans - flow / C << " " << n-flow % C <<endl;
}
return 0;
}1321: CX and girls
#include <iostream>
#include <cstring>
#include <cstdio>
#define MAXN 1010
#define MAXM 10100
#define INF 0x3f3f3f3f
using namespace std;
int n, m;
int dis[MAXN], vis[MAXN], map[MAXN][MAXN], cost[MAXN], total[MAXN];
int dijkstra()
{
for(int i = 2; i <= n; i++)
dis[i] = map[1][i];
vis[1] = 1;
dis[1] = 0;
total[1] = cost[1];
for(int i = 2; i <= n; i++)
total[i] = cost[i] + cost[1];
for(int i = 2; i <= n; i++)
{
int k = -1, minx = INF;
for(int j = 1; j <= n; j++)
{
if(!vis[j] && dis[j] < minx)
{
minx = dis[j];
k = j;
}
}
if(k == -1) break;
vis[k] = 1;
for(int j = 1; j <= n; j++)
{
if(vis[j]) continue;
if(dis[j] > dis[k] + map[k][j])
{
dis[j] = dis[k] + map[k][j];
total[j] = total[k] + cost[j];
}
else if(dis[j] == dis[k] + map[k][j])
{
if(total[j] < total[k] + cost[j])
total[j] = total[k] + cost[j];
}
}
}
return dis[n];
}
int main()
{
int a, b, c;
while(scanf("%d%d", &n, &m) != EOF)
{
memset(vis, 0, sizeof(vis));
memset(map, 0x3f, sizeof(map));
for(int i = 1; i <= n; i++)
{
scanf("%d", &cost[i]);
map[i][i] = 0;
}
for(int i = 1; i <= m; i++)
{
scanf("%d%d%d", &a, &b, &c);
if(c < map[a][b])
map[a][b] = map[b][a] = c;
}
int ans = dijkstra();
if(ans == INF) printf("-1\n");
else printf("%d\n", total[n]);
}
return 0;
}
/**********************************************************************
Problem: 1321
User: 3901140225
Language: C++
Result: AC
Time:412 ms
Memory:6024 kb
**********************************************************************/
#include <cstring>
#include <cstdio>
#define MAXN 1010
#define MAXM 10100
#define INF 0x3f3f3f3f
using namespace std;
int n, m;
int dis[MAXN], vis[MAXN], map[MAXN][MAXN], cost[MAXN], total[MAXN];
int dijkstra()
{
for(int i = 2; i <= n; i++)
dis[i] = map[1][i];
vis[1] = 1;
dis[1] = 0;
total[1] = cost[1];
for(int i = 2; i <= n; i++)
total[i] = cost[i] + cost[1];
for(int i = 2; i <= n; i++)
{
int k = -1, minx = INF;
for(int j = 1; j <= n; j++)
{
if(!vis[j] && dis[j] < minx)
{
minx = dis[j];
k = j;
}
}
if(k == -1) break;
vis[k] = 1;
for(int j = 1; j <= n; j++)
{
if(vis[j]) continue;
if(dis[j] > dis[k] + map[k][j])
{
dis[j] = dis[k] + map[k][j];
total[j] = total[k] + cost[j];
}
else if(dis[j] == dis[k] + map[k][j])
{
if(total[j] < total[k] + cost[j])
total[j] = total[k] + cost[j];
}
}
}
return dis[n];
}
int main()
{
int a, b, c;
while(scanf("%d%d", &n, &m) != EOF)
{
memset(vis, 0, sizeof(vis));
memset(map, 0x3f, sizeof(map));
for(int i = 1; i <= n; i++)
{
scanf("%d", &cost[i]);
map[i][i] = 0;
}
for(int i = 1; i <= m; i++)
{
scanf("%d%d%d", &a, &b, &c);
if(c < map[a][b])
map[a][b] = map[b][a] = c;
}
int ans = dijkstra();
if(ans == INF) printf("-1\n");
else printf("%d\n", total[n]);
}
return 0;
}1322: ZZY‘s new company
#include <iostream>
using namespace std;
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <cctype>
#include <vector>
#include <set>
#include <cstdlib>
#include <map>
#include <queue>
//#include<initializer_list>
//#include <windows.h>
//#include <fstream>
//#include <conio.h>
#define MaxN 0x7fffffff
#define MinN -0x7fffffff
#define lson 2*k
#define rson 2*k+1
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1e5+10;
int Scan()//读入整数外挂.
{
int res = 0, ch, flag = 0;
if((ch = getchar()) == '-') //判断正负
flag = 1;
else if(ch >= '0' && ch <= '9') //得到完整的数
res = ch - '0';
while((ch = getchar()) >= '0' && ch <= '9' )
res = res * 10 + ch - '0';
return flag ? -res : res;
}
void Out(int a) //输出外挂
{
if(a>9)
Out(a/10);
putchar(a%10+'0');
}
int n,q;
class Node
{
public:
int l;
int r;
int lazy;
int c[30];
};
Node node[4*maxn];
int val[maxn];
int ancestor[30][maxn];
int start[maxn];
int end1[maxn];
int entry[maxn];
int rentry[maxn];
int depth[maxn];
vector<int>G[maxn];
int getAncestor(int a,int dist)
{
for(int i=20; i>=0; i--)
{
if(dist & (1<<i))
{
a=ancestor[i][a];
}
}
return a;
}
void pushup(int k)
{
for (int i = 0; i < 30; i++)
{
node[k].c[i] = node[lson].c[i] + node[rson].c[i];
}
}
void pushdown(int k)
{
if(node[k].lazy)
{
for(int i=0; i<30; i++)
{
if(node[k].lazy & (1<<i) )
{
node[lson].c[i]=(node[lson].r-node[lson].l+1)-node[lson].c[i];
node[rson].c[i]=(node[rson].r-node[rson].l+1)-node[rson].c[i];
}
}
node[lson].lazy^=node[k].lazy;
node[rson].lazy^=node[k].lazy;
}
node[k].lazy=0;
}
void build(int l,int r,int k)
{
node[k].l=l;
node[k].r=r;
node[k].lazy=0;
if(l==r)
{
for(int i=0; i<30; i++)
{
node[k].c[i]=((val[rentry[l]]>>i)&1);
}
return ;
}
int mid=(l+r)/2;
build(l,mid,lson);
build(mid+1,r,rson);
pushup(k);
}
void chang(int l,int r,int k,int v)
{
if(l<=node[k].l&&node[k].r<=r)
{
for(int i=0; i<30; i++)
{
if(v&(1<<i))
{
node[k].c[i]=(node[k].r-node[k].l+1)-node[k].c[i];
}
}
node[k].lazy^=v;
return ;
}
pushdown(k);
int mid=(node[k].l+node[k].r)/2;
if(l<=mid) chang(l,min(mid,r),lson,v);
if(r>mid) chang(max(mid+1,l),r,rson,v);
pushup(k);
}
ll getAns(int l,int r,int k)
{
ll ans=0;
if(l<=node[k].l&&node[k].r<=r)
{
for(int i=0; i<30; i++)
{
ans+=(long long) node[k].c[i]<<i;
}
return ans;
}
pushdown(k);
int mid=(node[k].l+node[k].r)/2;
if(l<=mid) ans+=getAns(l,min(mid,r),lson);
if(r>mid) ans+=getAns(max(mid+1,l),r,rson);
return ans;
}
void bfs()//求bfs序
{
queue<int> q;
int DEF=1;//时间戳
q.push(1);
depth[1]=1;
while(!q.empty())
{
int s=q.front();
q.pop();
start[depth[s]]=min(start[depth[s]],DEF);
end1[depth[s]]=max( end1[depth[s]],DEF);
rentry[DEF]=s;
entry[s]=DEF++;
for(int j=0;j<(G[s].size());j++)
{
int son=G[s][j];
depth[son]=depth[s]+1;
q.push(son);
}
}
}
void init()
{
for(int i=0; i<=n; i++) G[i].clear();
memset(ancestor,-1,sizeof(ancestor));
memset(start,0x3f,sizeof(start));
memset(end1,0,sizeof(end1));
memset(depth,0,sizeof(depth));
memset(entry,0,sizeof(entry));
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("coco.txt","r",stdin);
freopen("lala.txt","w",stdout);
#endif
while(scanf("%d%d",&n,&q)!=EOF)
{
n++;
init();
for(int i=2; i<=n; i++)
{
scanf("%d%d",&ancestor[0][i],&val[i]);
ancestor[0][i]++;
G[ ancestor[0][i] ].push_back(i);
}
int li=log2(n)+1;
for(int k=0; k+1<li; k++)
{
for(int v=1; v<=n; v++)
{
if(ancestor[k][v]<0) ancestor[k+1][v]=-1;
else ancestor[k+1][v]=ancestor[k][ancestor[k][v]];
}
}
bfs();
build(1,n,1);
for(int i=0; i<q; i++)
{
int op,b,c,v;
scanf("%d%d%d",&op,&b,&c);
if(op==0)
{
scanf("%d",&v);
}
b++;
int d=c+depth[b];
if (d > n || start[d] == INF)
{
if (op == 1)
{
printf("-1\n");
}
continue;
}
int x, y;
{
int l = start[d], r = end1[d];
int ans = end1[d] + 1;
while (l <= r)
{
int mid = (l + r) >> 1;
if (entry[getAncestor(rentry[mid], c)] >= entry[b])
{
ans = mid;
r = mid - 1;
}
else
{
l = mid + 1;
}
}
x = ans;
}
{
int l = start[d], r = end1[d];
int ans = end1[d] + 1;
while (l <= r)
{
int mid = (l + r) >> 1;
if (entry[getAncestor(rentry[mid], c)] > entry[b])
{
ans = mid;
r = mid - 1;
}
else
{
l = mid + 1;
}
}
y = ans - 1;
}
if (y < x)
{
if (op)
{
printf("-1\n");
}
continue;
}
if (op == 0)
{
chang(x,y,1,v);
}
else
{
printf("%lld\n", getAns(x,y,1));
}
}
}
return 0;
}1326: The contest
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
using namespace std;
int father[10000];
int dp[2000],s[2000][3];
int path[1005][1005],f[1005];
int t[1005];
int find(int x)
{
int root,i=x;
while(father[x]!=x)
x=father[x];
root=x;
while(father[i]!=root)
{
int tmp=father[i];
father[i]=root;
i=tmp;
}
return root;
}
void liantong(int x,int y)
{
x=find(x);
y=find(y);
father[x]=y;
}
int main()
{
int n,ans,k;
while(scanf("%d%d%d",&n,&ans,&k)!=EOF)
{
memset(dp,0,sizeof(dp));
//memset(p,0,sizeof(p));
memset(f,0,sizeof(f));
for(int i=0;i<=n;i++)
father[i]=i;
for(int i=1;i<=n;i++)
{
scanf("%d%d",&s[i][0],&s[i][1]);
s[i][2]=i;
}
for(int i=1;i<=k;i++)
{
int tmp,tmp1;
scanf("%d%d",&tmp,&tmp1);
tmp=find(tmp);
tmp1=find(tmp1);
if(tmp!=tmp1)
liantong(tmp,tmp1);
}
for(int i=1;i<=n;i++)
{
int tmp=find(i);
path[tmp][f[tmp]++]=i;
//printf("%d\n",tmp);
}
int cnt=1;
for(int i=1;i<=n;i++)
{
if(f[i]==1)
{
t[cnt++]=i;
//printf("%d\n",i);
}
}
for(int i=1;i<=n;i++)
{
if(f[i]==1||f[i]==0)
continue;
for(int j=ans;j>=0;j--)
{
for(int iter=0;iter<f[i];iter++)
{
int tmp=path[i][iter];
if(j-s[tmp][1]>=0)
{
if(dp[j]<dp[j-s[tmp][1]]+s[tmp][0])
dp[j]=dp[j-s[tmp][1]]+s[tmp][0];
}
}
}
}
for(int i=1;i<cnt;i++)
{
int tmp=t[i];
for(int j=ans;j>=s[tmp][1];j--)
{
if(dp[j]<dp[j-s[tmp][1]]+s[tmp][0])
dp[j]=dp[j-s[tmp][1]]+s[tmp][0];
}
}
printf("%d\n",dp[ans]);
}
return 0;
}1327: Scholarship
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
#define INF 0x7fffffff
#define maxn 1005
#define mod 1000000007
int x,n,m;
int a[15];
int d[15];
void judge(){
int b[15]={0};
memset(d,0,sizeof d);
int i=0;
while(x){b[i++]=x%10;x/=10;}
int k=i;
for(int i=1;i<=k;i++)d[i]=b[k-i];
for(i=1;i<k&&i>=0;)
if(d[i]==d[i+1]&&d[i]!=0){
d[i+1]=(d[i+1]+1)%10;
while(d[i+1]==0&&i>=0){d[i]=(d[i]+1)%10;i--;}
if(d[i]!=d[i+1])break;
}
else i++;
x=0;
for(int j=0;j<=i+1;j++)x=x+d[j]*a[k-j];
}
int main(){
a[0]=1;
for(int i=1;i<10;i++)a[i]=a[i-1]*10;
scanf("%d",&n);
while(n--){
scanf("%d",&x);
if(x<0){printf("0\n");continue;}
x++;
judge();
printf("%d\n",x);
}
return 0;
}1328: 近似回文词
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#include<string>
#define ll long long
#define N 1110
using namespace std;
int n,m;
char s[N],s1[N];
int num[N];
int main() {
//freopen("in.txt","r",stdin);
int ca=1;
while(~scanf("%d",&m)) {
getchar();
gets(s);
int len=strlen(s);
int k=0;
for(int i=0; i<len; i++) {
if(s[i]>='A'&&s[i]<='Z') {
s1[k]=s[i]+32;
num[k++]=i;
} else if(s[i]>='a'&&s[i]<='z') {
s1[k]=s[i];
num[k++]=i;
}
}
s1[k]='\0';
int Max=1;
int l=0;
for(int i=0; i<k; i++) {
int w=m;
int j,jk;
for( j=i-1,jk=i+1; ; j--,jk++) {///以i为中心点
if(j<0||jk>=k)break; ///不知道为什么，这个放for()里，就错了，求告知
if(s1[j]!=s1[jk]&&w==0) {
break;
}
if(s1[j]!=s1[jk])
w--;
}
j++,jk--;
if(j<=jk) {
if(num[jk]-num[j]+1>Max) {
Max=num[jk]-num[j]+1;
l=num[j];
} else if(num[jk]-num[j]+1==Max) {
l=min(l,num[j]);
}
}
w=m;
for(j=i,jk=i+1; ; j--,jk++) {///以i和i+1中间为中心点
if(j<0||jk>=k)break;
if(s1[j]!=s1[jk]&&w==0) {
break;
}
if(s1[j]!=s1[jk])
w--;
}
j++,jk--;
if(j<=jk) {
if(num[jk]-num[j]+1>Max) {
Max=num[jk]-num[j]+1;
l=num[j];
} else if(num[jk]-num[j]+1==Max) {
l=min(l,num[j]);
}
}
}
printf("Case %d: %d %d\n",ca++,Max,l+1);
}
}
1329: 一行盒子
#include<stdio.h>
#include<string.h>
const int N = 100005 ;
struct NODE
{
int l , r ;
}node[N];
int main()
{
int n , m , op , x , y ;
int T = 0;
while(scanf("%d%d",&n,&m)>0)
{
for(int i=0; i<=n; i++)
node[i].l=i-1 , node[i].r = i+1 ;
int flag = 0 , tmp;
while(m--)
{
scanf("%d",&op);
if(op==4)
flag ^= 1 ;
else{
scanf("%d%d",&x,&y);
if(op==3){ //注意3的交换操作
if(node[x].l==y){
node[node[x].r].l=y; node[node[y].l].r=x;
node[x].l = node[y].l; node[y].l=x;
node[y].r = node[x].r; node[x].r=y;
}
else if(node[y].l==x){
node[node[y].r].l=x; node[node[x].l].r=y;
node[y].l = node[x].l; node[x].l=y;
node[x].r = node[y].r; node[y].r=x;
}
else{
node[node[x].l].r= y ; node[node[x].r].l = y;
node[node[y].l].r= x ; node[node[y].r].l = x;
tmp = node[x].l ; node[x].l=node[y].l; node[y].l=tmp;
tmp = node[x].r ; node[x].r=node[y].r; node[y].r=tmp;
}
continue ;
}
node[node[x].l].r = node[x].r ; //提出x之前 处理x左值的右指向为x右指向的值
node[node[x].r].l = node[x].l ; //同理
if(flag)op = 3 - op ; //如果4操作次数为奇数次，操作要反向操作
if(op==2){ //x值放在y值的右边
node[x].l = y ; node[x].r = node[y].r;
node[node[x].r].l = x ;
node[y].r = x;
}
else{ //x值放在y值的左边
node[x].l=node[y].l; node[x].r = y ;
node[node[x].l].r = x ;
node[y].l = x ;
}
/*int id = 0 ;
for(int i=1; i<=n; i++)
printf("%d ",node[id].r) , id = node[id].r;
printf("\n");*/
}
}
if(flag&&(n&1))flag = 0 ;
int k = 1 , id = node[0].r ;
long long ans = 0;
while(k<=n)
{
if((k&1))
ans += id ;
k++ ; id = node[id].r ;
}
if(flag) ans = (long long )n*(n+1)/2 - ans ;
printf("Case %d: %lld\n",++T , ans ) ;
}
}
1330: 字符识别？
#include <stdio.h>
#define N 50
int n;
char s[5][N];
int main()
{
while(scanf("%d",&n)>0)
{
for(int i=0;i<5;i++)
scanf("%s",s[i]);
for(int i=0;i<4*n;i+=4)
{
if(s[0][i]=='.')
{
printf("1");
continue;
}
else
{
if(s[3][i]=='*')
{
printf("2");
continue;
}
else
{
printf("3");
continue;
}
}
}
printf("\n");
}
return 0;
}1332: 割耳法
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<functional>
#define eps 1e-9
#include<vector>
const double INF = 1e9;
using namespace std;
double d[200][200];
const double PI = acos(-1.0);
int dcmp(double x){ if (abs(x) < eps) return 0; else return x < 0 ? -1 : 1; }
struct point{
double x, y;
point(double x = 0, double y = 0) :x(x), y(y){}
}node[112];
typedef point Vector;
struct segment{
point a, b; segment(){}
segment(point _a, point _b){ a = _a, b = _b; }
};
struct circle{
point c; double r; circle(){}
circle(point _c, double _r) :c(_c), r(_r) {}
point PPP(double a)const{ return point(c.x + cos(a)*r, c.y + sin(a)*r); }
};
struct line{
point p, v; double ang;
line() {}
line(const point &_p, const point &_v) :p(_p), v(_v){ ang = atan2(v.y, v.x); }
inline bool operator < (const line &L)const{ return ang < L.ang; }
};
point operator + (point a, point b){ return point(a.x + b.x, a.y + b.y); }
point operator - (point a, point b){ return point(a.x - b.x, a.y - b.y); }
point operator * (point a, double b){ return point(a.x*b, a.y*b); }
point operator / (point a, double b){ return point(a.x / b, a.y / b); }
bool operator < (const point &a, const point &b){ return a.x < b.x || (a.x == b.x && a.y < b.y); }
bool operator == (const point &a, const point &b){ return (dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0); }
bool operator != (const point &a, const point &b){ return a == b ? false : true; }
double Dot(point a, point b){ return a.x*b.x + a.y*b.y; }
double Length(point a){ return sqrt(Dot(a, a)); }
double Angle(point a, point b){ return acos(Dot(a, b) / Length(a) / Length(b)); }
double D_T_D(const double deg){ return deg / 180.0*PI; }
double Cross(point a, point b){
return a.x*b.y - a.y*b.x;
}
bool SegmentProperIntersection(const point& a1, const point& a2, const point& b1, const point& b2) {
double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
return dcmp(c1)*dcmp(c2)<0 && dcmp(c3)*dcmp(c4)<0;
}
bool online(const point a, const point b, const point pot){
if (Cross(a - pot, b - pot) == 0 && Dot(a - pot, b - pot) <= 0)return 1;
return 0;
}
int isinpoly(const point& p, const vector<point> poly){
int n = poly.size();
int wn = 0;
for (int i = 0; i < n; i++){
const point& p1 = poly[i];
const point& p2 = poly[(i + 1) % n];
if (p1 == p || p2 == p || online(p1, p2, p)) return -1;
int k = dcmp(Cross(p2 - p1, p - p1));
int d1 = dcmp(p1.y - p.y);
int d2 = dcmp(p2.y - p.y);
if (k > 0 && d1 <= 0 && d2 > 0) wn++;
if (k < 0 && d2 <= 0 && d1 > 0) wn--;
}
if (wn != 0) return 1;
return 0;
}
bool isDgnal(const vector<point>poly, int a, int b)
{
int i, n = poly.size();
for (i = 0; i<n; i++)
if (i != a && i != b && online(poly[a], poly[b], poly[i])) return false;
for (i = 0; i<n; i++)
if (SegmentProperIntersection(poly[i], poly[(i + 1) % n], poly[a], poly[b])) return false;
point mid = (poly[a] + poly[b])*0.5;
return (isinpoly(mid, poly) == 1);
}
double go(const vector<point> poly)
{
int i, j, k, n = poly.size();
for (i = 0; i<n; i++)
for (j = 0; j<n; j++)
d[i][j] = -1;
for (i = n - 2; i >= 0; i--)
for (j = i + 1; j<n; j++)
{
double len = Length(poly[i] - poly[j]);
if (i + 1 == j) d[i][j] = 0;
else if (!(i == 0 && j == n - 1) && !isDgnal(poly, i, j)) d[i][j] = INF;
else
{
double m = INF;
for (k = i + 1; k<j; k++)
m = min(m, d[i][k] + d[k][j]);
d[i][j] = len + m;
}
}
double len0 = Length(poly[0] - poly[n - 1]);
return d[0][n - 1] - len0;
}
int main()
{
int n, cas = 1;
while (~scanf("%d", &n) && n)
{
double x, y;
vector <point> poly;
for (int i = 0; i<n; i++)
{
scanf("%lf%lf", &x, &y);
poly.push_back(point(x, y));
}
printf("Case %d: %.4lf\n", cas++, go(poly));
}
}1333: Funny Car Racing
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define ll long long
const ll INF = 1LL<<60 ;
const ll N = 305 ;
struct EDG
{
ll to , next ;
ll a , b , c , d ;
} edg[50010];
ll eid , head[N] ;
ll dis[N] ;
void init()
{
eid = 0;
memset(head , -1 , sizeof(head));
for(ll i = 0 ; i < N ; i++)
dis[i] = INF ;
}
void addEdg(ll u , ll v , ll a , ll b , ll c)
{
edg[eid].to = v ;
edg[eid].next = head[u] ;
edg[eid].a = a ;
edg[eid].b = b ;
edg[eid].c = c ;
edg[eid].d = a + b ;
head[u] = eid++;
}
void spfa(ll s , ll t)
{
queue<ll>q;
bool inq[N] = { 0 } ;
ll u , v ;
dis[s] = 0 ;
if(s != t )
q.push( s ) ;
while(!q.empty())
{
u = q.front() ;
q.pop() ;
inq[u] = 0 ;
for(ll i = head[u] ; i!=-1; i=edg[i].next)
{
v = edg[i].to ;
ll tt = edg[i].a - (dis[u]%edg[i].d);
if(tt<edg[i].c)
tt += edg[i].b ;
else
tt = 0 ;
if(dis[v] > dis[u] + tt +edg[i].c)
{
dis[v] = dis[u] + tt +edg[i].c ;
if(inq[v]==0&&v!=t)
inq[v] = 1 , q.push(v);
}
}
}
}
int main()
{
ll n , m , s , t , u , v , a , b , c ;
ll T = 0;
while(scanf("%lld%lld%lld%lld",&n,&m,&s,&t)>0)
{
init();
while(m--)
{
scanf("%lld%lld%lld%lld%lld",&u , &v , &a , &b , &c) ;
if(c<=a)
addEdg( u , v , a , b , c );
}
spfa(s , t ) ;
if(dis[t]==INF)
dis[t] = -1;
printf("Case %lld: %lld\n",++T,dis[t]);
}
}1334: 好老师
#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
using namespace std;
int main()
{
char q[101][4];
int left,right,i,s,m,n;
cin>>n;
for(i=1;i<=n;i++)
scanf("%s",q[i]);
cin>>m;
while(m--)
{
cin>>s;
left=right=s;
if(q[s][0]!='?')
cout<<q[s]<<endl;
else
{
while(1)
{
if(left-1>0)
left=left-1;
if(right+1<=n)
right=right+1;
if(q[left][0]!='?'&&q[right][0]!='?')
{
printf("middle of %s and %s\n",q[left],q[right]);
break;
}
if(q[left][0]=='?'&&q[right][0]!='?')
{
for(i=1;i<=right-s;i++)
cout<<"left of ";
printf("%s\n",q[right]);
break;
}
if(q[left][0]!='?'&&q[right][0]=='?')
{
for(i=1;i<=s-left;i++)
cout<<"right of ";
printf("%s\n",q[left]);
break;
}
}
}
}
return 0;
}1336: Interesting Calculator
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define maxn 100050
#define INF 0x3f3f3f3f
using namespace std;
int cost[3][10];
int dis[maxn],num[maxn];
int vis[maxn];
int st,ed;
int Case=1;
void spfa()
{
memset(dis,INF,sizeof(dis));
memset(vis,0,sizeof(vis));
queue<int>q;
int u,v,t;
q.push(st);
num[st]=dis[st]=0;
while(!q.empty())
{
u=q.front();
q.pop();
vis[u]=0;
for(int i=0; i<3; i++)
for(int j=0; j<10; j++)
{
if(i==0)
v=u*10+j;
else if(i==1)
v=u+j;
else
v=u*j;
if(v>ed) //注意是break +1 *1 *10+1 都爆了 就不用考虑后面那些了
break;
if(dis[v]<=dis[u]+cost[i][j])
continue;
dis[v]=dis[u]+cost[i][j];
num[v]=num[u]+1;
if(!vis[v])
{
vis[v]=1;
q.push(v);
}
}
}
printf("Case %d: %d %d\n",Case++,dis[ed],num[ed]);
}
int main()
{
while(~scanf("%d%d",&st,&ed))
{
for(int i=0; i<3; i++)
for(int j=0; j<10; j++)
scanf("%d",&cost[i][j]);
spfa();
}
return 0;
}1339: 最后一滴血
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct node{
int time,id;
}q[20];
int d[20][105];
int main()
{
int n,t,m;
cin>>n>>t>>m;
int ans=0;
for(int i=0;i<12;i++)
{
q[i].time=-1;
q[i].id=0;
}
memset(d,0,sizeof(d));
for(int i=0;i<m;i++)
{
char a,b[10];
int time,c;
cin>>time>>c>>a>>b;
int tt=a-'A';
ans=max(ans,tt);
if(b[0]=='Y')
{
if(q[tt].time<=time)
{
if(d[tt][c]==0)
{
q[tt].time=time;
q[tt].id=c;
d[tt][c]=1;
}
}
}
}
for(int i=0;i<=ans;i++)
{
printf("%c ",i+'A');
if(q[i].time!=-1)
printf("%d %d",q[i].time,q[i].id);
else
printf("- -");
printf("\n");
}
return 0;
} 1350: To Add Which?
#include<iostream>
#include<cstdio>
#define M 100100
using namespace std;
int num[M],Max[M],Min[M];
int max(int a,int b)
{
return a>b?a:b;
}
int main()
{
int T,n,D;
long long ans;
cin>>T;
while(T--){
ans=0;
cin>>n>>D;
for(int i=0;i<n;i++) cin>>num[i];
Max[0]=num[0];
for(int i=1;i<n;i++)
{
if(Max[i-1]-num[i]>D)
Max[i]=Max[i-1]-D;
else Max[i]=num[i];
}
Min[n-1]=num[n-1];
for(int i=n-2;i>=0;i--)
{
if(Min[i+1]-num[i]>D)
Min[i]=Min[i+1]-D;
else Min[i]=num[i];
}
for(int i=0;i<n;i++) ans+=(max(Min[i],Max[i])-num[i]);
cout<<ans<<endl;
}
return 0;
}1352: New Sorting Algorithm
#include<cstdio>
#include<algorithm>
#define maxn 100005
using namespace std;
int n,t,m;
int num[maxn],f[maxn],r[maxn],cnt[maxn];
bool cmp(const int &x,const int &y)
{
return num[x]<num[y];
}
int find(int x)
{
return f[x]==x?x:f[x]=find(f[x]);
}
void merge(int x,int y)
{
int xx=find(x);
int yy=find(y);
if(xx!=yy)f[yy]=xx,cnt[xx]+=cnt[yy];
}
void pre()
{
for(int i=1; i<=n; i++)r[i]=i;
sort(r+1,r+n+1,cmp);
for(int i=1; i<=n; i++)num[r[i]]=i;
for(int i=1; i<=n; i++)f[i]=i,cnt[i]=1;
}
void solve()
{
long long ans=0;
bool flag=1;
for(int i=r[1]; i<n; i++)
if(num[i]>num[i+1])
{
flag=0;
break;
}
if(flag)m=r[1]-1;
else m=n;
for(int i=1; i<=m; i++)
{
int v=num[i];
ans+=cnt[v];
merge(v-1,v);
}
printf("%lld\n",ans);
}
int main()
{
// freopen("test0.in","r",stdin);
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=1; i<=n; i++)
scanf("%d",&num[i]);
pre();
solve();
}
return 0;
}1355: 地雷清除计划
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <bitset>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
#define fuck(x) cout<<"["<<x<<"]";
#define FIN freopen("input.txt","r",stdin);
#define FOUT freopen("output.txt","w+",stdout);
//#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
typedef long long LL;
typedef pair<int, int>PII;
const int MX = 1e3;
const int MS = 4e5 + 5;
const int INF = 0x3f3f3f3f;
template<class T>
struct Max_Flow {
int n;
int Q[MX], sign;
int head[MX], level[MX], cur[MX], pre[MX];
int nxt[MS], pnt[MS], E;
T cap[MS];
void Init(int n) {
E = 0;
this->n = n + 1;
fill(head, head + this->n, -1);
}
void Add(int from, int to, T c, T rw = 0) {
pnt[E] = to; cap[E] = c; nxt[E] = head[from]; head[from] = E++;
pnt[E] = from; cap[E] = rw; nxt[E] = head[to]; head[to] = E++;
}
bool BFS(int s, int t) {
sign = t;
std::fill(level, level + n, -1);
int *front = Q, *tail = Q;
*tail++ = t; level[t] = 0;
while (front < tail && level[s] == -1) {
int u = *front++;
for (int e = head[u]; e != -1; e = nxt[e]) {
if (cap[e ^ 1] > 0 && level[pnt[e]] < 0) {
level[pnt[e]] = level[u] + 1;
*tail++ = pnt[e];
}
}
}
return level[s] != -1;
}
void Push(int t, T &flow) {
T mi = INF;
int p = pre[t];
for (int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
mi = std::min(mi, cap[p]);
}
for (int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
cap[p] -= mi;
if (!cap[p]) {
sign = pnt[p ^ 1];
}
cap[p ^ 1] += mi;
}
flow += mi;
}
void DFS(int u, int t, T &flow) {
if (u == t) {
Push(t, flow);
return;
}
for (int &e = cur[u]; e != -1; e = nxt[e]) {
if (cap[e] > 0 && level[u] - 1 == level[pnt[e]]) {
pre[pnt[e]] = e;
DFS(pnt[e], t, flow);
if (level[sign] > level[u]) {
return;
}
sign = t;
}
}
}
T Dinic(int s, int t) {
pre[s] = -1;
T flow = 0;
while (BFS(s, t)) {
std::copy(head, head + n, cur);
DFS(s, t, flow);
}
return flow;
}
};
Max_Flow<int>F;
char s[MX];
int T, n, m, k;
PII P[MX]; int tot;
int dist(PII a, PII b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
inline bool check(PII a, PII b, int k) {
if((a.first == b.first || a.second == b.second) && dist(a, b) <= 2 * k + 1) return 1;
if((a.first != b.first && a.second != b.second) && dist(a, b) <= 2 * k + 2) return 1;
return 0;
}
int main() {
//FIN;
scanf("%d", &T);
while(T--) {
tot = 0;
scanf("%d%d%d", &n, &m, &k);
for(int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for(int j = 1; j <= m; j++) {
if(s[j] == '*') P[++tot] = PII(i, j);
}
}
int s = 0, t = 2 * tot + 1;
F.Init(t + 1);
for(int i = 1; i <= tot; i++) {
F.Add(i, i + tot, 1);
if(P[i].first + k >= n || P[i].second - k <= 1) {
F.Add(s, i, INF);
}
if(P[i].first - k <= 1 || P[i].second + k >= m) {
F.Add(i + tot, t, INF);
}
for(int j = i + 1; j <= tot; j++) {
if(check(P[i], P[j], k)) {
F.Add(i + tot, j, INF);
F.Add(j + tot, i, INF);
}
}
}
printf("%d\n", F.Dinic(s, t));
}
return 0;
}1356: Catch
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int INF = 1000000007;
const double eps = 1e-10;
const int maxn = 100010;
const int MOD = 9997;
int n;
int m, st;
int tot;
vector<int>adj[maxn];
int vis[maxn];
int fla;
int dfs(int x, int fa, int val)
{
if (vis[x] == -1) vis[x] = val;
else return vis[x];
tot++;
for (int i = 0; i < adj[x].size(); i++)
{
int y = adj[x][i];
//if (y != fa)
//{
if (vis[x] == dfs(y, x, vis[x] ^ 1))
fla = 1;
//}
}
return vis[x];
}
int main ()
{
int T;
cin >> T;
int x, y;
int ncase = 1;
while (T--)
{
memset(vis, -1, sizeof(vis));///初始化为-1，染成0和1
cin >> n >> m >> st;
for (int i = 0; i< n; i++) adj[i].clear();
while (m--)
{
scanf("%d%d", &x,&y);
adj[x].push_back(y);
adj[y].push_back(x);
}
fla = 0;///判断是否找到奇环
tot = 0;///记录联通的点数
dfs(st, -1, 0);
printf("Case %d: ", ncase++);
if (fla && tot == n) puts("YES");
else puts("NO");
}
return 0;
}
1364: Interview
#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
using namespace std;
const int MAXN = (int)2e5+5;
int ST[21][MAXN]; //Sparse Table
int hight[MAXN];
int n, k;
inline int topBit(int x) {
return (int) (log((double)x)/log(2.0));
}
inline int Query(int L, int R) {
int h = hight[R-L];
if ((R-L) < (1<<h)) h -= 1;
return max(ST[h][L], ST[h][R-(1<<h)]);
}
int main() {
#ifdef Phantom01
freopen("CSU1364.in", "r", stdin);
#endif // Phantom01
memset(hight, 0, sizeof(hight));
for (int i = 1; i < MAXN; i++) //比他左位移一位的数高一
hight[i] = hight[i>>1] + 1;
while (scanf("%d %d", &n, &k)!=EOF) {
if (-1==n && -1==k) break;
for (int i = 0; i < n; i++)
scanf("%d", &ST[0][i]); //最下面一层就是原始数据
int h = hight[n];
for (int i = 1; i <= h; i++) {
for (int j = 0; j < n; j++) {
if ((j+(1<<(i-1))) < n)
ST[i][j] = max(ST[i-1][j], ST[i-1][j+(1<<(i-1))]);
else
ST[i][j] = ST[i-1][j];
}
}
int ans = -1;
for (int i = n; i > 0; i--) {
int m = n/i;
int tmp = 0;
for (int j = 0; j < m; j++) {
tmp += Query(j*i, (j+1)*i);
if (tmp>k) {
ans = j+1; //不知道这里为啥是j+1而不是 m
break;
}
}
if (tmp > k)
break;
}
printf("%d\n", ans);
}
return 0;
}1366: A New Year Gift
#include<iostream>
using namespace std;
#include<string.h>
int a[1005];
int main()
{
int n, m;
while(cin >> n && n)
{
memset(a,0,sizeof(a));
int sum = 0;
for(int i = 0;i < n;i ++)
{
cin >> a[i];
sum += a[i];
}
cin >> m; //m种颜色
int maxn = sum / m; //理论上最多的条数
int minn = 0;
while(minn < maxn)
{
int mid = (maxn + minn) / 2;
sum = 0;
for(int i = 0;i < n;i ++)
{
sum += (a[i] >= mid ? mid : a[i]);
}
if(sum >= mid * m)
minn = mid + 1;
else
maxn = mid - 1;
}
sum = 0;
for(int i = 0;i < n;i ++)
{
sum += (a[i] >= minn ? minn : a[i]);
}
if(sum >= minn * m) cout << minn << endl;
else cout << minn - 1 << endl;
}
return 0;
} 1371: Maximum Shortest Distance
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define N 500
using namespace std;
int n, k, cnt, l, r, mid, le;
double ans;
int x[N], y[N], d[N][N], dist[1000000], a[N], some[N][N], all[N][N], none[N][N];
int getdist(int u, int v)
{
return (x[u] - x[v]) * (x[u] - x[v]) + (y[u] - y[v]) * (y[u] - y[v]);
}
int dfs(int deep, int an, int sn, int nn)
{
if (an >= k) return 1;
if (an + sn < k) return 0;
int u = some[deep][1];
for (int i = 1; i <= sn; i++)
{
int v = some[deep][i];
int tsn = 0, tnn = 0;
if (d[u][v] >= le) continue;
for (int j = 1; j <= an; j++) all[deep+1][j] = all[deep][j];
all[deep+1][an+1] = v;
for (int j = 1; j <= sn; j++)
if (d[v][some[deep][j]] >= le) some[deep+1][++tsn] = some[deep][j];
for (int j = 1; j <= nn; j++)
if (d[v][none[deep][j]] >= le) none[deep+1][++tnn] = none[deep][j];
if (dfs(deep+1, an+1, tsn, tnn)) return 1; // 这里要return 1;
some[deep][i] = 0;
none[deep][++nn] = v;
}
return 0;
}
int main()
{
while(~scanf("%d%d", &n, &k))
{
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]);
cnt = 0;
memset(d, 0, sizeof(d));
for (int i = 1; i < n; i++)
for (int j = i+1; j <= n; j++)
{
d[i][j] = getdist(i, j);
d[j][i] = d[i][j];
cnt++;
dist[cnt] = d[i][j];
}
sort(dist+1, dist+cnt+1);
l = 1;
r = cnt;
while (l <= r)
{
mid = (l + r) / 2;
le = dist[mid];
a[0] = 0;
for (int i = 1; i <= n; i++) some[1][i] = i;
if (dfs(1, 0, n, 0))
{
l = mid + 1;
ans = sqrt(dist[mid]);
}
else
{
r = mid - 1;
}
}
printf("%.2f\n", ans);
}
return 0;
}
1374: Restore Calculation
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
using namespace std;
const int mod=1e9+7;
const int maxn=60;
char ch1[maxn],ch2[maxn],ch3[maxn];
int dp[maxn][2];
int main()
{
while(scanf("%s",ch1)&&ch1[0]!='0')
{
scanf("%s",ch2);
scanf("%s",ch3);
memset(dp,0,sizeof(dp));
int len=strlen(ch1);
dp[len][0]=1; //为什么初始化这个没搞懂
int i,j,k,l,s,m;
for(i=len-1;i>=0;i--)
{
for(j=(i)?0:1;j<10;j++) //i=0 j=1
{
if(ch1[i]-'0'!=j&&ch1[i]!='?') continue;
for(k=(i)?0:1;k<10;k++)
{
if(ch2[i]-'0'!=k&&ch2[i]!='?') continue;
for(l=0;l<2;l++)
{
s=(j+k+l)/10; m=(j+k+l)%10;
if(m==ch3[i]-'0'||ch3[i]=='?')
dp[i][s]=(dp[i+1][l]+dp[i][s])%mod; //这个式子！！！
}
}
}
}
cout<<dp[0][0]<<endl;
}//while
return 0;
}1378: Shipura
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
using namespace std;
typedef long long ll;
const ll MOD = (ll)1e9+7;
const int MAXN = (int)2e6+9;
stack<ll> num;
stack<char> op;
char str[MAXN];
char str2[MAXN];
inline ll S(ll x) {
return (x*x)%MOD;
}
void pushNum(ll x) {
while (!op.empty() && '^'==op.top()) { //其实这个用if就好了，因为>>运算时先计算左边，所以栈中不会出现连续的>>运算
op.pop();
ll tmp = num.top(); num.pop();
if (x>60) {
tmp = 0;
x = 0;
}
x = (tmp>>x);
}
num.push(x);
}
void slove() {
int i = 0;
ll tmp;
while (true) {
if ('\0'==str[i]) break;
while (' '==str[i]) i++;
if ('S'==str[i]) {
op.push('S');
i++;
continue;
}
if ('<'==str[i]) {
i++;
continue;
}
if ('0'<=str[i]&&str[i]<='9') {
tmp = 0;
while ('0'<=str[i]&&str[i]<='9') {
tmp *=10;
tmp += str[i]-'0';
i++;
}
pushNum(tmp);
continue;
}
if ('>'==str[i]) {
if ('>'==str[i+1] && ('S'==str[i+2] || ('0'<=str[i+2]&&str[i+2]<='9'))) {
op.push('^');
i++;
}else if ('S'==op.top()) {
op.pop();
tmp = num.top(); num.pop();
pushNum(S(tmp));
}
i++;
continue;
}
}
printf("%lld\n", num.top());
}
void Transform(){
int i = 0, j = 0;
while (true) {
if ('\0'==str2[i]) break;
if (' '==str2[i]) while (' '==str2[i]) i++;
else {
str[j++] = str2[i++];
}
}
str[j] = '\0';
}
int main()
{
#ifdef Phantom01
freopen("CSU1378.txt", "r", stdin);
#endif // Phantom01
while (gets(str2)) {
if ('#'==str2[0]&&'\0'==str2[1]) break;
while (!num.empty()) num.pop();
while (!op.empty()) op.pop();
Transform();
slove();
}
return 0;
}1383: A Easy Problem
#include <cstdio>
#include <iostream>
#include <algorithm>
#define LL long long
#define ULL unsigned long long
#define mem(a,n) memset(a,n,sizeof(a))
#define fread freopen("in.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)
#define N 10100
#define INF 0x3f3f3f3f
#define eps 1e-9
using namespace std;
ULL gcd(ULL a,ULL b){
return (b==0?a:gcd(b,a%b));
}
ULL nume[20000],demo[10000];
int main()
{
ULL a,b,c,t,cnt1,cnt2,i,j;
cin>>t;
while(t--){
cin>>a>>b;
c=1;
cnt1=cnt2=0;
if(a==b||b==0){
cout<<1<<endl;
continue;
}
if(b==a-1||b==1){
cout<<a<<endl;
continue;
}
b=min(b,a-b);
for(i=a-b+1;i<=a;++i){
nume[cnt1++]=i;
}
for(i=2;i<=b;++i){
demo[cnt2++]=i;
}
for(i=0;i<cnt2;++i){
for(j=0;demo[i]!=1&&j<cnt1;++j){
ULL n=gcd(demo[i],nume[j]);
demo[i]/=n;
nume[j]/=n;
}
}
for(int i=0;i<cnt1;++i){
c*=nume[i];
}
cout<<c<<endl;
}
return 0;
}1390: Planting Trees
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int a[100100];
bool cmp(int a, int b) {
return a > b;
}
int main()
{
int n;
cin >> n;
for(int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a+n, cmp);
int max = 0;
for(int i = 0; i < n; i++) {
a[i] = a[i] + i + 2;
if(max < a[i]) max = a[i];
}
printf("%d\n", max);
return 0;
} 1391: Boiling Vegetables
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
double vagetable[1100],limit;
int n;
int main()
{
cin>>limit>>n;
for(int i=0;i<n;i++) cin>>vagetable[i];
if(n==1)
{
cout<<0<<endl;
return 0;
}
sort(vagetable,vagetable+n,less<double>());
int ans=501;
for(int i=0;i<n;i++)
{
for(int c=0;c<ans;c++)
{
double maxsize=vagetable[i]/(c+1);
double minsize=maxsize*limit;
int temp=c;
bool flag=true;
for(int j=0;j<n;j++)
{
if(i==j) continue;
int c1=(int)ceil(vagetable[j]/maxsize)-1;
if(vagetable[j]/(c1+1) < minsize)
{
flag=false; break;
}
temp+=c1;
if(temp>=ans)
{
flag=false; break;
}
}
if(flag)
{
ans=min(ans,temp);
}
}
}
cout<<ans<<endl;
return 0;
}
1392: Number Trick
#include <cstdio>
typedef long long ll;
using namespace std;
int power[10],a[10010],ans=0;
float x,tmpx;//不知道为什么用double会wa
ll f1,f2;
int digit(ll tmp)
{
int tot=0;
while(tmp) tot++,tmp/=10;
return tot;
}
int head(ll tmp)
{
for (; tmp>=10; tmp/=10);
return tmp;
}
int main()
{
power[0]=1;
for (int i=1; i<=9; i++) power[i]=power[i-1]*10;
scanf("%f",&x);
if (x>=10)
{
printf("No solution\n");
return 0;
}
for (int i=1; i<=8; i++)//枚举总共几个数位
for (int j=1; j<=9; j++)//枚举开头数字
{
tmpx=100000-10000*x;
f1=(int)tmpx;
f2=(ll)10000*(power[i]-1)*j;
if (f2%f1!=0) continue;
f2/=f1;
if (digit(f2)==i && head(f2)==j) a[++ans]=f2;
}
if (ans==0) printf("No solution\n");
else for (int i=1; i<=ans; i++) printf("%d\n",a[i]);
return 0;
}1393: Robert Hood
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 100000+10;
int n,m;
struct Point{
double x,y;
Point(){};
Point(double _x, double _y)
{
x = _x;
y = _y;
}
Point operator - (const Point & B) const
{
return Point(x-B.x, y-B.y);
}
}p[maxn], ch[maxn];
bool cmp(Point p1, Point p2)
{
if(p1.x == p2.x) return p1.y < p2.y;
return p1.x < p2.x;
}
int squarDist(Point A, Point B) /**距离的平方*/
{
return (A.x-B.x)*(A.x-B.x) + (A.y-B.y)*(A.y-B.y);
}
double Cross(Point A, Point B) /**叉积*/
{
return A.x*B.y-A.y*B.x;
}
void ConvexHull() /** 基于水平的Andrew算法求凸包 */
{
sort(p,p+n,cmp); /**先按照 x 从小到大排序, 再按照 y 从小到大排序*/
m = 0;
for(int i = 0; i < n; i++) /** 从前往后找 */
{
while(m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
ch[m++] = p[i];
}
int k = m;
for(int i = n-2; i >= 0; i--) /**从后往前找, 形成完整的封闭背包*/
{
while(m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
ch[m++] = p[i];
}
if(n > 1) m--;
}
int rotating_calipers() /**旋转卡壳模板*/
{
int q = 1;
int ans = 0;
ch[m] = ch[0]; /**凸包边界处理*/
for(int i = 0; i < m; i++) /**依次用叉积找出凸包每一条边对应的最高点*/
{
while(Cross(ch[i+1]-ch[i], ch[q+1]-ch[i]) > Cross(ch[i+1]-ch[i], ch[q]-ch[i]))
q = (q+1)%m;
ans = max(ans, max(squarDist(ch[i], ch[q]), squarDist(ch[i+1], ch[q+1])));
}
return ans;
}
int main()
{
while(scanf("%d", &n) != EOF)
{
if(n == 0) break;
for(int i = 0; i < n; i++)
scanf("%lf%lf", &p[i].x, &p[i].y);
ConvexHull();
printf("%.8lf\n", sqrt(rotating_calipers()));
}
return 0;
}1408: 种植树苗
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define LL long long
using namespace std;
const int MAX = 1e6+10;
const int INF = 0x3fffffff;
int a[MAX];
bool check[MAX];
int main(){
int t;
cin>>t;
while(t--){
memset(a,0,sizeof(a));
memset(check,true,sizeof(check));
int n,d;
scanf("%d%d",&n,&d);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
sort(a,a+n);
int l = 0;
for(int i=1;i<n;i++){
if(a[i]-a[l]>=d){
l = i;
}
else{
check[i] = false;
}
}
int num = 0;
for(int i=0;i<n;i++){
if(check[i]) num++;
}
cout<<num<<endl;
}
return 0;
}
1409: 集合的并
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=200005;
int n,m;
struct point
{
int x,y;
}f[maxn];
bool mycomp(const point &a,const point &b)
{
if(a.x!=b.x) return a.x<b.x;
else return a.y>b.y;
}
void solve()
{
int i,ans = 0;
int start=0;
for(i=0;i<n+m;i++)
{
if(f[i].x>start) start=f[i].x;
if (f[i].y>=start)
{
ans+=f[i].y-start+1;
start = f[i].y+1;
}
}
printf("%d\n",ans);
}
int main()
{
int t,i;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(i=0;i<n;i++) scanf("%d %d",&f[i].x,&f[i].y);
scanf("%d",&m);
for(i=n;i<m+n;i++) scanf("%d %d",&f[i].x,&f[i].y);
sort(f,f+n+m,mycomp);
solve();
}
return 0;
}1411: Longest Consecutive Ones
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long int LL;
const int maxn=100100;
LL pos[maxn],sum[maxn],K;
int cnt;
char str[maxn];
bool ck(int l,int r)
{
int mid=(l+r)/2;
LL temp=0;
int num=mid-l;
temp+=pos[mid]*num-num*(num+1)/2-sum[mid-1]+sum[l-1];
num=r-mid;
temp+=sum[r]-sum[mid]-num*(num+1)/2-pos[mid]*num;
if(temp>K)
return false;
return true;
}
int main()
{
int T_T;
scanf("%d",&T_T);
while(T_T--)
{
scanf("%s",str+1);
scanf("%I64d",&K);
int len=strlen(str+1);
cnt=1;
for(int i=1;i<=len;i++)
{
if(str[i]=='1')
{
pos[cnt]=i;
sum[cnt]=pos[cnt]+sum[cnt-1];
cnt++;
}
}
cnt--;
int i=1,ans=0,maxn=1;
while(true)
{
int j=i+maxn-1;
if(j>cnt) break;
if(ck(i,j))
{
ans=maxn; maxn++;
}
else i++;
}
printf("%d\n",ans);
}
return 0;
}1412: Line and Circles
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;
#define inf 1e20
#define eps 1e-8
const int N = 100005 ;
const double PI = 2.0*asin(1.0); //高精度求PI
struct Lpoint
{
double x,y;
}a[N], b[N]; //点
struct Llineseg
{
Lpoint a,b;
}; //线段
struct Ldir
{
double dx,dy;
}; //方向向量
struct Lline
{
Lpoint p;
Ldir dir;
}; //直线
bool mult(Lpoint sp, Lpoint ep, Lpoint op)
{
return (sp.x - op.x) * (ep.y - op.y)
>= (ep.x - op.x) * (sp.y - op.y);
}
bool operator < (const Lpoint &l, const Lpoint &r)
{
return l.y < r.y || (l.y == r.y && l.x < r.x);
}
int graham(Lpoint pnt[], int n, Lpoint res[])
{
int i, len, top = 1;
sort(pnt, pnt + n);
if (n == 0) return 0;
res[0] = pnt[0];
if (n == 1) return 1;
res[1] = pnt[1];
if (n == 2) return 2;
res[2] = pnt[2];
for (i = 2; i < n; i++)
{
while (top && mult(pnt[i], res[top], res[top-1]))
top--;
res[++top] = pnt[i];
}
len = top;
res[++top] = pnt[n - 2];
for (i = n - 3; i >= 0; i--)
{
while (top!=len && mult(pnt[i], res[top], res[top-1])) top--;
res[++top] = pnt[i];
}
return top; // 返回凸包中点的个数
}
void format(Lline ln, double& A, double& B, double& C)
{
A=ln.dir.dy;
B=-ln.dir.dx;
C=ln.p.y*ln.dir.dx-ln.p.x*ln.dir.dy;
}
double p2ldis(Lpoint a, Lline ln)
{
double A,B,C;
format(ln,A,B,C);
return(fabs(A*a.x+B*a.y+C)/sqrt(A*A+B*B));
}
double CPMD(Lpoint p[], int n)//ConvexPolygonMinimumDiameter
{
int i, j;
double ans = inf, tmp;
p[n] = p[0];
Lline ln;
Ldir dir;
for(i = 0, j = 1; i < n; ++i)
{
if((i+1)%n == j) j = (j + 1) % n;
dir.dx = p[i].x - p[i+1].x;
dir.dy = p[i].y - p[i+1].y;
ln.dir = dir;
ln.p = p[i];
while((tmp = p2ldis(p[j], ln)) < (p2ldis(p[(j+1)%n], ln)))
j = (j + 1) % n;
ans = min(ans, tmp);
}
return ans;
}
double dis(Lpoint u, Lpoint v)
{
return sqrt((u.x-v.x) * (u.x-v.x) + (u.y - v.y)*(u.y - v.y));
}
int main()
{
int n, t;
double r;
scanf("%d", &t);
while(t--)
{
scanf("%d%lf", &n, &r);
for(int i = 0; i < n; i++)
scanf("%lf%lf", &a[i].x, &a[i].y);
int m = graham(a, n, b);
if(m <= 2)
{
printf("Yes\n");
continue;
}
double k = CPMD(b, m);
if(k - 2*r < eps)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}1414: Query on a Tree
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn=110000;
struct Edge
{
int to,next;
}edge[maxn];
int Adj[maxn],Size;
vector<int> eg[maxn];
vector<int> pre_sum[maxn];
int dfn[maxn][2],sons[maxn],max_deep[maxn],Deep[maxn],id[maxn],ti,maxdeep,n;
void init(int n)
{
Size=0;
memset(Adj,-1,sizeof(Adj));
memset(dfn,0,sizeof(dfn));
memset(sons,0,sizeof(sons));
memset(Deep,0,sizeof(Deep));
memset(id,0,sizeof(id));
memset(max_deep,0,sizeof(max_deep));
ti=0;maxdeep=0;
for(int i=0;i<=n+20;i++)
{
pre_sum[i].clear(),pre_sum[i].push_back(0);
eg[i].clear(),eg[i].push_back(0);
}
}
void Add_Edge(int u,int v)
{
edge[Size].to=v;
edge[Size].next=Adj[u];
Adj[u]=Size++;
}
void DFS(int u,int deep)
{
dfn[u][0]=++ti;
maxdeep=max(maxdeep,deep);
eg[deep].push_back(u);
int maxd=0;
for(int i=Adj[u];~i;i=edge[i].next)
{
int v=edge[i].to;
DFS(v,deep+1);
maxd=max(maxd,max_deep[v]);
}
max_deep[u]=maxd+1;
Deep[u]=deep;
dfn[u][1]=ti;
sons[u]=dfn[u][1]-dfn[u][0]+1;
}
void prefix_sum()
{
for(int i=1;i<=maxdeep;i++)
{
for(int j=1,sz=eg[i].size();j<sz;j++)
{
id[eg[i][j]]=j;
pre_sum[i].push_back( pre_sum[i][j-1]+sons[eg[i][j]] );
}
}
}
void Debug()
{
for(int i=1;i<=n;i++)
{
cout<<i<<" st: "<<dfn[i][0]<<" et: "<<dfn[i][1]<<" sons: "<<sons[i]<<endl;
}
cout<<"maxdeep: "<<maxdeep<<endl;
for(int i=1;i<=maxdeep;i++)
{
cout<<i<<": "<<endl;
for(int j=0,sz=eg[i].size();j<sz;j++)
{
cout<<eg[i][j]<<",";
}
cout<<endl;
}
cout<<"id: \n";
for(int i=1;i<=maxdeep;i++)
{
cout<<i<<": "<<endl;
for(int j=0,sz=eg[i].size();j<sz;j++)
{
cout<<id[eg[i][j]]<<",";
}
cout<<endl;
}
cout<<"prefix_sum: \n";
for(int i=1;i<=maxdeep;i++)
{
cout<<i<<": "<<endl;
for(int j=0,sz=eg[i].size();j<sz;j++)
{
cout<<pre_sum[i][j]<<",";
}
cout<<endl;
}
cout<<"max_deep: ";
for(int i=1;i<=n;i++)
{
cout<<i<<" : "<<max_deep[i]<<endl;
}
}
void solve(int x,int d)
{
int nowd=Deep[x];
if(d>=max_deep[x])
{
printf("%d\n",sons[x]);
return ;
}
int qd=nowd+d;
int L=0,R=0,sz=eg[qd].size();
int low,mid,high;
low=0,high=sz-1;
while(low<=high)
{
mid=(low+high)/2;
int ps=eg[qd][mid];
if(dfn[ps][0]>=dfn[x][0])
{
L=eg[qd][mid-1]; high=mid-1;
}
else low=mid+1;
}
///...get right pos
low=0,high=sz-1;
while(low<=high)
{
mid=(low+high)/2;
int ps=eg[qd][mid];
if(dfn[ps][1]<=dfn[x][1])
{
R=ps; low=mid+1;
}
else high=mid-1;
}
printf("%d\n",sons[x]-pre_sum[qd][id[R]]+pre_sum[qd][id[L]]);
}
int main()
{
int T_T;
scanf("%d",&T_T);
while(T_T--)
{
scanf("%d",&n);
init(n+1);
for(int i=2;i<=n;i++)
{
int fa;
scanf("%d",&fa);
Add_Edge(fa,i);
}
DFS(1,1);
prefix_sum();
int q;
scanf("%d",&q);
while(q--)
{
int x,d;
scanf("%d%d",&x,&d);
solve(x,d);
}
}
return 0;
}
1416: Practical Number
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
#define N 100008
int prime[N],cnt,vis[N];
void init()
{
cnt=0;
memset(vis,0,sizeof(vis));
for(int i=2;i<N;i++)
{
if(vis[i]) continue;
prime[cnt++]=i;
for(int j=i+i;j<N;j+=i)
vis[j]=1;
}
}
int solve(long long n)
{
if(n==1) return 1;
if(n&1) return 0;
long long now=1;
for(int i=0;i<cnt;i++)
{
if(n%prime[i]==0)
{
if(prime[i]>now+1) return 0;
long long temp=1,sum=1;
while(n%prime[i]==0)
{
n/=prime[i];
temp*=prime[i];
sum+=temp;
}
now*=sum;
}
}
if(n>now+1) return 0;
return 1;
}
int main()
{
int T;
long long n;
init();
scanf("%d",&T);
while(T--)
{
scanf("%lld",&n);
if(solve(n)) printf("Yes\n");
else printf("No\n");
}
return 0;
}
1424: Qz’s Maximum All One Square
#include<stdio.h>
#include<math.h>
#define maxn 1010
int sum[maxn][maxn];
int main()
{
int m,n,t;
while(~scanf("%d%d",&n,&m))
{
int i,j,k,ans;
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&k);
sum[i][j]=k+sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];//用个小技巧，求(i,j）到（1，1）这个点的1的个数。
//printf("%d ",sum[i][j]);
}
//printf("\n");
}
ans=0;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{
t=ans;//每次从边长等于ans+1开始找！一个小剪枝，否则会超时。
int x,y;
for(x=i-ans,y=j-ans;x&&y;x--,y--)
{
if(x<=0||y<=0)break;
int temp1=sum[i][j]-sum[i][y-1]-sum[x-1][j]+sum[x-1][y-1];
if(temp1==(t+1)*(t+1))
{
t++;
}
else break;
}
if(t>ans)ans=t;
}
printf("%d\n",ans*ans);
}
return 0;
} 1425: Prime Summation
#include <stdio.h>
#include <string.h>
#define N 205
int n, k;
int f[N][N];
int prime[N], cnt;
bool isprime[N];
void get_prime()
{
cnt = 0;
memset(isprime, 0, sizeof isprime);
for(int i = 2; i < N; i++)
{
if(!isprime[i])
{
prime[cnt++] = i;
for(int j = i*2; j < N; j += i)
isprime[j] = true;
}
}
}
int main()
{
get_prime();
while(scanf("%d%d", &n, &k) != EOF)
{
memset(f, 0, sizeof f);
f[0][0] = 1;
for(int i = 2; i <= n; i++)
{
for(int j = 0; j < cnt; j++)
{
if(prime[j] > i) break;
for(int t = 0; t <= prime[j]; t++)
f[i][prime[j]] += f[i-prime[j]][t];
}
}
int sum = 0;
for(int i = 0; i <= n; i++)
sum += f[n][i];
if(k > sum) k = sum;
printf("%d\n%d=", sum, n);
k = sum - k;
bool flag = false;
do
{
int cnt = 0;
int i;
for(i = 2; i <= n; i++)
{
if(cnt + f[n][i] > k)
break;
cnt += f[n][i];
}
n -= i;
k = k - cnt;
if(flag) printf("+");
flag = true;
printf("%d", i);
}
while(n != 0);
printf("\n");
}
return 0;
}1427: Infected Computer
#include <iostream>
#include <algorithm>
#include <stdio.h>
#define max 20005
#define ll long long
using namespace std;
struct G{
int from;
int to;
ll time;
}game[max];
bool graf[max];
bool cmp(G a,G b){
return a.time < b.time;
}
int main()
{
int n,m;
while(cin>>n>>m){
for(int i = 0;i < max;i++){
graf[i]=false;
game[i].time=game[i].from=game[i].to=0;
}
graf[1]=true;
for(int i = 0;i < m;i++){
cin>>game[i].time>>game[i].from>>game[i].to;
}
sort(game,game+m,cmp);
bool flag = false;
for(int i = 0;i < m;i++){
if(game[i].from==1){
flag = true;
//graf[game[i].to] = true;
}
if(flag&&graf[game[i].from]){
graf[game[i].to] = true;
}
}
ll ans = 0;
for(int i = 1;i <= n;i++){
if(graf[i])ans++;
}
cout<<ans<<endl;
}
return 0;
}1433: Defend the Bases
#include <iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<cmath>
#define maxn 110
using namespace std;
int n,m;
struct Troop
{
double x,y,v;
};
Troop a[maxn];
struct Base
{
double x,y;
};
Base b[maxn];
int head[maxn];
struct Edge
{
int to,next;
};
Edge e[10010];
int cnt_edge;
int vis[maxn];
int mat[maxn];
int match;
void init()
{
memset(head,-1,sizeof head);
memset(mat,0,sizeof mat);
cnt_edge = 0;
match = 0;
}
void add_edge(int a,int b)
{
e[cnt_edge].to = b;
e[cnt_edge].next = head[a];
head[a] = cnt_edge;
cnt_edge++;
}
bool crosspath(int k)
{
for(int i = head[k]; i !=-1; i = e[i].next)
{
int j = e[i].to;
if(!vis[j])
{
vis[j] = 1;
if(!mat[j] || crosspath(mat[j]))
{
mat[j] = k;
return true;
}
}
}
return false;
}
void hungary()
{
for(int i = 1; i <= n; i++)
{
memset(vis,0,sizeof vis);
if(crosspath(i))
{
match++;
}
}
}
double dis(int i,int j)
{
double temp = sqrt((a[i].x - b[j].x)*(a[i].x - b[j].x) + (a[i].y - b[j].y)*(a[i].y - b[j].y));
return temp/a[i].v;
}
int main()
{
while(scanf("%d %d",&n,&m)!=EOF)
{
for(int i = 1; i <= n; i++)
{
scanf("%lf %lf %lf",&a[i].x,&a[i].y,&a[i].v);
}
for(int i = 1; i <= m; i++)
{
scanf("%lf %lf",&b[i].x,&b[i].y);
}
double low = 0;
double high = 15000;
double mid;
while(high - low > 0.000000001)
{
mid = (low + high)/2;
init();
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
{
if(dis(i,j) < mid)
{
add_edge(i,j);
}
}
hungary();
int flag = 1;
for(int i = 1; i <= m; i++)
{
if(!mat[i])
{
flag = 0;
break;
}
}
if(flag) high = mid;
else low = mid;
}
printf("%.10lf\n",mid);
}
return 0;
}
1436: Revenge of the Round Table
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1010;
const int mod = 1000003;
typedef long long LL;
int dpA[maxn][maxn],dpB[maxn][maxn],dp[maxn];
int n,k;
LL ans,all;
void DP(){
memset(dpA,0,sizeof(dpA));
memset(dpB,0,sizeof(dpB));
memset(dp,0,sizeof(dp));
int asum = 1,bsum = 0;
if(k >= n){
k = n-1;
all = 2;
}
dpA[1][1] = 1;
dpB[1][1] = 0;
for(int i = 2;i <= n;i++){
dpA[i][1] = bsum;
dpB[i][1] = asum;
swap(asum,bsum);
for(int j = 2;j <= min(n,k);j++){
dpA[i][j] = dpA[i-1][j-1];
asum = (asum+dpA[i][j])%mod;
dpB[i][j] = dpB[i-1][j-1];
bsum = (bsum+dpB[i][j])%mod;
}
}
for(int i = 1;i <= n;i++){
for(int j = 1;j <= min(n,k);j++){
dp[i] += dpB[i][j];
dp[i] %= mod;
}
}
for(int i = 1;i <= n;i++){
for(int j = 1;j < k;j++){
dpB[i][j+1] += dpB[i][j];
dpB[i][j+1] %= mod;
}
}
for(int i = 1;i <= n;i++){
for(int p = 1;p <= min(i,k);p++){
dp[i] += dpB[i-p][k-p];
dp[i] %= mod;
}
}
}
int gcd(int a,int b){
return b == 0 ? a : gcd(b,a%b);
}
LL pow_mod(LL a,LL n){
LL ret = 1;
while(n){
if(n&1) ret = ret*a%mod;
n >>= 1;
a = a*a%mod;
}
return ret;
}
int main()
{
while(scanf("%d%d",&n,&k) == 2){
ans = 0,all = 0;
DP();
for(int i = 0;i < n;i++){
ans += 2*dp[gcd(i,n)];
ans %= mod;
}
ans = ans*pow_mod(n,mod-2)%mod;
printf("%lld\n",(ans+all)%mod);
}
return 0;
}1438: Swyper Keyboard
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <assert.h>
#include <algorithm>
#define MAX 1234567890
#define MIN -1234567890
#define eps 1e-8
using namespace std;
int cnt;
char key[104];
char road[20004];
/// * A B C D E * 00 01 02 03 04 05 06 ** 00 01 02 03 04 **
/// F G H I J K L 07 08 09 10 11 12 13 05 06 07 08 09 10 11
/// M N O P Q R S 14 15 16 17 18 19 20 12 13 14 15 16 17 18
/// T U V W X Y Z 21 22 23 24 25 26 27 19 20 21 22 23 24 25
int P[28][2] = {
{2, 8}, {4, 8}, {6, 8}, {8, 8}, {10, 8}, {12, 8}, {14, 8},
{2, 6}, {4, 6}, {6, 6}, {8, 6}, {10, 6}, {12, 6}, {14, 6},
{2, 4}, {4, 4}, {6, 4}, {8, 4}, {10, 4}, {12, 4}, {14, 4},
{2, 2}, {4, 2}, {6, 2}, {8, 2}, {10, 2}, {12, 2}, {14, 2},
};
int pos[26] = {
1, 2, 3, 4, 5,
7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27,
};
int ret[28] = {
0, 0, 1, 2, 3, 4, 0,
5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25,
};
int judge(int x1, int y1, int x2, int y2)
{
return x1*y2 - x2*y1;
}
///给定起点位置和终点位置
void findroad(int first, int last)
{
int dx = P[last][0] > P[first][0] ? 1 : -1;
int dy = P[last][1] > P[first][1] ? 1 : -1;
if(P[last][0] == P[first][0])
{
if(dy > 0) for(int i = first-7; i >= last; i -= 7) road[cnt++] = 'A' + ret[i];
if(dy < 0) for(int i = first+7; i <= last; i += 7) road[cnt++] = 'A' + ret[i];
}
else if(P[last][1] == P[first][1])
{
if(dx > 0) for(int i = first+1; i <= last; i += 1) road[cnt++] = 'A' + ret[i];
if(dx < 0) for(int i = first-1; i >= last; i -= 1) road[cnt++] = 'A' + ret[i];
}
else
{
int next = first;
int sx = P[last][0] - P[first][0];
int sy = P[last][1] - P[first][1];
while((P[next][0] != P[last][0] || P[next][1] != P[last][1]) && next >= 0 && next <= 27)
{
int tmpx = P[next][0] + dx;
int tmpy = P[next][1] + dy;
int tmpj = judge(sx, sy, tmpx - P[first][0], tmpy - P[first][1]);
if(dx < 0 && dy < 0)
{
if(tmpj < 0) next += 7;
if(tmpj > 0) next -= 1;
if(tmpj == 0) next += 6;
}
if(dx > 0 && dy < 0)
{
if(tmpj < 0) next += 1;
if(tmpj > 0) next += 7;
if(tmpj == 0) next += 8;
}
if(dx > 0 && dy > 0)
{
if(tmpj < 0) next -= 7;
if(tmpj > 0) next += 1;
if(tmpj == 0) next -= 6;
}
if(dx < 0 && dy > 0)
{
if(tmpj < 0) next -= 1;
if(tmpj > 0) next -= 7;
if(tmpj == 0) next -= 8;
}
if(next != 0 && next != 6) road[cnt++] = 'A' + ret[next];
}
}
}
int main()
{
#ifdef BellWind
freopen("12823.in", "r", stdin);
#endif // BellWind
int T;
scanf("%d", &T);
while(T--)
{
int n;
scanf("%d %s", &n, key);
cnt = 0;
memset(road, 0, sizeof(road));
int len = strlen(key);
road[cnt++] = key[0];
for(int l = 0; l+1 < len; l++) findroad(pos[key[l]-'A'], pos[key[l+1]-'A']);
road[cnt] = '\0';
// puts(road);
bool flag = true;
for(int t = 0; t < n; t++)
{
char word[104];
scanf("%s", word);
if(flag)
{
int lenw = strlen(word);
int k, l;
for(l = 0, k = 0; l < cnt && k < lenw; l++) if(word[k] == road[l]) k++;
if(k == lenw)
{
flag = false;
printf("%s\n", word);
}
}
}
if(flag) printf("NO SOLUTION\n");
}
return 0;
} 1442: NASSA’s Robot
#include <iostream>
using namespace std;
int main()
{
int T;
cin >> T;
while(T--)
{
int x, y, n;
x = y = n = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++)
switch(s[i])
{
case 'U': y += 1; break;
case 'D': y -= 1; break;
case 'L': x -= 1; break;
case 'R': x += 1; break;
case '?': n += 1; break;
}
printf("%d %d %d %d\n", x-n, y-n, x+n, y+n);
}
return 0;
}1446: Modified LCS
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
typedef long long ll;
using namespace std;
ll x, y, g;
void exgcd(ll a, ll b) {
if (b == 0) {
x = 1;
y = 0;
g = a;
return;
}
exgcd(b, a%b);
ll t = x;
x = y;
y = t - a / b * y;
return;
}
int main() {
int t;
ll n1, n2, f1, f2, d1, d2;
scanf("%d", &t);
while (t--) {
cin >> n1 >> f1 >> d1 >> n2 >> f2 >> d2;
ll f = f2 - f1;
exgcd(d1, -d2);
if (f % g) {
printf("0\n");
continue;
}
else {
ll r = abs((-d2)/g);
x = ((x * f / g) % r + r) % r;
y = (f - x * d1) / (-d2);
ll dx = abs(d1 / g);
ll dy = abs(d2 / g);
ll ans = min((n1 - 1 - x) / dy, (n2 - 1 - y) / dx) + 1;
cout << ans << endl;
}
}
return 0;
}1447: Mario Kart
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <iomanip>
#include <queue>
#include <vector>
#include <set>
#include <map>
#define LL long long
#define inf 0x3f3f3f3f
#define P system("pause")
using namespace std;
#define M 105
int cost[105],val[105],n,m,L;
int p[105],g[M][M],dp[1005],dis[M],vis[M];
void DP()//背包
{
for(int i=0;i<1005;i++)
dp[i]=inf;
dp[0]=0;
for(int i=0;i<m;i++)
{
for(int j=p[n-1]-p[0];j>=val[i];j--)
dp[j]=min(dp[j],dp[j-val[i]]+cost[i]);
}
}
void build()//建图
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
g[i][j]=(p[i]==p[j])?0:inf;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(dp[p[j]-p[i]]<=L){
g[i][j]=g[j][i]=1;
//cout<<p[i]<<"->"<<p[j]<<endl;
}
}
}
}
int dij(int u)//dijskstra求最短路
{
int i,j,v;
memset(vis,0,sizeof(vis));
for(i=0;i<n;i++)
dis[i]=g[u][i];
dis[u]=0;
vis[u]=1;
for(i=1;i<n;i++)
{
int mi=inf,v=u;
for(j=0;j<n;j++)
{
if(!vis[j]&&dis[j]<mi){
mi=dis[j];
v=j;
}
}
vis[v]=1;
for(j=0;j<n;j++)
{
if(!vis[j]&&dis[j]>dis[v]+g[v][j])
dis[j]=dis[v]+g[v][j];
}
}
int ans=dis[n-1];
if(ans==inf)
return -1;
return ans;
}
int main()
{
int t,i;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&n,&m,&L);
for(i=0;i<n;i++)
scanf("%d",&p[i]);
for(i=0;i<m;i++)
scanf("%d%d",&cost[i],&val[i]);
sort(p,p+n);
DP();
build();
printf("%d\n",dij(0));
}
return 0;
}1453: 平衡序列
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
const int maxn = 100000+20;
struct data
{
int L,R,mx; //每个节点，都记录一个区间[L,R]。还有记录区间总和
int mid() {return (L + R)/2;}
}SegTree[maxn<<2]; //右移两位，就是*4
void built (int root,int begin,int end)
{
SegTree[root].L = begin; SegTree[root].R = end;//覆盖区间
if (begin == end)
{
SegTree[root].mx = 0; return ;
}
built(root<<1,begin,SegTree[root].mid());
built(root<<1|1,SegTree[root].mid()+1,end);
SegTree[root].mx = max(SegTree[root<<1].mx,SegTree[root<<1|1].mx);
return ;
}
void add (int root,int pos,int val)
{
if (SegTree[root].L == pos && pos == SegTree[root].R)
{
SegTree[root].mx = val; return ;
}
if (pos <= SegTree[root].mid()) add(root<<1,pos,val);
else if (pos >= SegTree[root].mid()+1) add(root<<1|1,pos,val);
SegTree[root].mx = max (SegTree[root<<1].mx,SegTree[root<<1|1].mx);
return ;
}
//[begin,end]是要查询的区间，如果所求区间包含线段树覆盖区间，就可以返回
int find (int root,int begin,int end) //区间查询
{
//查询[1,7]的话，左子树区间覆盖了[1,6]，也可以直接返回,左子树最大值嘛
if (begin <= SegTree[root].L && end >= SegTree[root].R) return SegTree[root].mx; //覆盖了
if (end <= SegTree[root].mid()) //完全在左子数
return find(root<<1,begin,end);
else if (begin >= SegTree[root].mid() + 1) //完全在右子树
return find(root<<1|1,begin,end);
else
{
int Lmax = find(root<<1,begin,end);
int Rmax = find(root<<1|1,begin,end);
return max(Lmax,Rmax);
}
}
void work ()
{
built(1,0,maxn-20);
int n;
int k;
scanf ("%d%d",&n,&k);
for (int i=1;i<=n;++i)
{
int x;
scanf ("%d",&x);
int a = max(0,x-k);
int b = min(maxn-20,x+k);
int t = find(1,a,b);
add(1,x,t+1);
}
printf ("%d\n",find(1,0,maxn-20));
return ;
}
int main()
{
#ifdef local
freopen("data.txt","r",stdin);
#endif
int t;
scanf ("%d",&t);
while(t--) work();
return 0;
}1457: Boggle
#include <queue>
#include <cstdio>
#include <set>
#include <string>
#include <stack>
#include <cmath>
#include <climits>
#include <map>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long(LL);
typedef unsigned long long(ULL);
const double eps(1e-8);
int score,num;
bool v[5000010],vv[10][10];
int dx[]= {1,1,0,-1,-1,-1,0,1};
int dy[]= {0,1,1,1,0,-1,-1,-1};
int val[]={0,0,0,1,1,2,3,5,11,11,11};
char str[300010][10],Mat[4][5],ans[10],tmp[10];
struct node
{
node *Next[26];
int sc,num;
bool flag;
node()
{
for(int i=0; i<26; ++i) Next[i]=NULL;
num=0,sc=-1;
}
} *root;
void Insert(char *s,int id)
{
node *p=root;
int i=0,idx;
while(s[i])
{
idx=s[i]-'A';
if(p->Next[idx]==NULL)
p->Next[idx]=new node();
p=p->Next[idx];
++i;
}
p->num=id;
p->sc=val[strlen(s)];
}
void Matching(char *s)
{
int i=0,idx;
node *p=root;
int len=strlen(s);
while(s[i])
{
idx=s[i]-'A';
if(p->Next[idx]==NULL) break;
p=p->Next[idx];
++i;
}
if(v[p->num]==false && p->sc!=-1)
{
++num;
score+=p->sc;
v[p->num]=true;
if(num==1 || (strlen(s)>strlen(ans)) || ((strlen(s)==strlen(ans) && strcmp(s,ans)<0)) )
memcpy(ans,s,10);
}
}
void dfs(int x,int y,int cnt)
{
if(cnt>8) return;
tmp[cnt-1]=Mat[x][y];
tmp[cnt]='\0';
Matching(tmp);
vv[x][y]=true;
for(int i=0;i<8;++i)
{
int xx=x+dx[i];
int yy=y+dy[i];
if(vv[xx][yy]!=true && (xx>=0&&xx<4&&yy>=0&&yy<4))
{
vv[x][y]=1;
dfs(xx,yy,cnt+1);
vv[x][y]=0;
}
}
vv[x][y]=0;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
int n,m;
scanf("%d",&n);
root=new node();
for(int i=0; i<n; ++i)
{
scanf("%s",str[i]);
Insert(str[i],i);
}
scanf("%d",&m);
while(m--)
{
memset(v,0,sizeof v);
score=num=0;
for(int i=0; i<4; ++i)
scanf("%s",Mat[i]);
for(int i=0; i<4; ++i)
for(int j=0; j<4; ++j)
dfs(i,j,1);
printf("%d %s %d\n",score,ans,num);
}
return 0;
}1458: Booking
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef struct nnn
{
int st;
int et;
}node;
node book[5005];
int cmp(node a,node b)
{
if(a.st==b.st)
return a.et<b.et;
return a.st<b.st;
}
int Fun(int a,int b)
{
if(a<=b)
return 0;
return 1;
}
int main()
{
int i,i1,j,t,c,b,ans,sy,ey,sm,em,sd,ed,sh,eh;
int d[14]={0,31,28,31,30,31,30,31,31,30,31,30,31};
char str[30];
scanf("%d",&t);
while(t--)
{
ans=1;
scanf("%d%d",&b,&c);
for(i=0;i<b;i++)
{
scanf("%s",str);
scanf("%d-%d-%d %d:%d %d-%d-%d %d:%d",&sy,&sm,&sd,&sh,&book[i].st,&ey, &em,&ed, &eh, &book[i].et);
book[i].st+=(sh*60+(sd-1)*24*60);
for(i1=2013;i1<=sy; i1++)
if(i1<sy)
{
book[i].st+=(365*24*60);
if(i1%400==0||i1%4==0&&i1%100!=0)
book[i].st+=(24*60);
}
else
{
if((i1%400==0||i1%4==0&&i1%100!=0)&&2<sm)
book[i].st+=(24*60);
for(j=1;j<sm; j++)
book[i].st+=(d[j]*60*24);
}
book[i].et+=(eh*60+c+(ed-1)*24*60);
for( i1=2013;i1<=ey; i1++)
if(i1<ey)
{
book[i].et+=(365*24*60);
if(i1%400==0||i1%4==0&&i1%100!=0)
book[i].et+=(24*60);
}
else
{
if((i1%400==0||i1%4==0&&i1%100!=0)&&2<em)
book[i].et+=(24*60);
for(j=1;j<em; j++)
book[i].et+=(d[j]*60*24);
}
}
sort(book,book+b,cmp);
int tim[5005],k=0;
tim[k++]=book[0].et;
for(i=1;i<b;i++)//关建要注意的
{
for(j=0;j<k;j++)
if(Fun(tim[j],book[i].st)==0)
break;
if(j==k){
ans+=1;
tim[k++]=book[i].et;
}
else
tim[j]=book[i].et;
}
printf("%d\n",ans);
}
return 0;
}
1460: Kastenlauf
#include<stdio.h>
#include<queue>
#include<iostream>
using namespace std;
typedef struct nnn
{
int x,y;
}NODE;
int n;
NODE node[105];
int abs(int a)
{
return a>0?a:-a;
}
int bfs()
{
queue<NODE>q;
NODE p;
int vist[105]={0};
q.push(node[1]);
while(!q.empty())
{
p=q.front(); q.pop();
if(abs(p.x-node[n].x)+abs(p.y-node[n].y)<=1000)
return 1;
for(int i=2; i<n; i++)
if(vist[i]==0&&abs(p.x-node[i].x)+abs(p.y-node[i].y)<=1000)
{
vist[i]=1; q.push(node[i]);
}
}
return 0;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
n+=2;
for(int i=1; i<=n; i++)
scanf("%d%d",&node[i].x,&node[i].y);
int flog=bfs();
printf("%s\n",flog?"happy":"sad");
}
}
1469: Handles
#include <stdio.h>
#include <string.h>
using namespace std;
char a[1005][1005];
int xx[1005],yy[1005];
int n,m;
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
memset(xx,0,sizeof(xx));
memset(yy,0,sizeof(yy));
for(int i=0;i<n;i++)
scanf("%s",a[i]);
int q;
scanf("%d",&q);
while(q--)
{
int x,y;
scanf("%d%d",&x,&y);
a[x-1][y-1]=(a[x-1][y-1]=='+'?'-':'+');
xx[x-1]++;
yy[y-1]++;
}
for(int i=0;i<n;i++)
{
if(xx[i]%2!=0)
{
for(int j=0;j<m;j++)
a[i][j]=(a[i][j]=='+'?'-':'+');
}
}
for(int i=0;i<m;i++)
{
if(yy[i]%2!=0)
{
for(int j=0;j<n;j++)
a[j][i]=(a[j][i]=='+'?'-':'+');
}
}
int sum=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(a[i][j]=='+')
sum++;
printf("%d\n",sum);
}
return 0;
}
1484: Central Avenue Road
#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
const int maxn=105;
int x[maxn],y[maxn];
int n;
double dist(int i,int j)
{
return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+0.000001);
}
bool judge(int i,int j)
{
int a=y[j]-y[i];
int b=x[i]-x[j];
int c=x[j]*y[i]-x[i]*y[j];
int u=x[i]-x[j];
int d=y[i]-y[j];
int lf=0,rt=0;
if(u==0&&d!=0)
{
for(int k=0; k<n; k++)
{
if(x[k]<x[i])
{
lf++;
}
if(x[k]>x[i])
{
rt++;
}
}
}
else if(d==0&&u!=0)
{
for(int k=0; k<n; k++)
{
if(y[k]<y[i])
{
lf++;
}
if(y[k]>y[i])
{
rt++;
}
}
}
else
{
for(int k=0; k<n; k++)
{
if(a*x[k]+b*y[k]+c>0)
{
lf++;
}
else if(a*x[k]+b*y[k]+c<0)
{
rt++;
}
}
}
if(fabs(rt-lf)<=1) return true;
else return false;
}
int main()
{
while(~scanf("%d",&n)&&n)
{
for(int i=0; i<n; i++)
{
scanf("%d%d",&x[i],&y[i]);
}
double Max=0x3f3f3f3f3f;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(judge(i,j)){
double temp=dist(i,j);
if(temp<Max)
Max=temp;
}
}
}
printf("%.3lf\n",Max);
}
return 0;
}
1497: The Gougu Theorem
#include<iostream>
#include<algorithm>
using namespace std;
#include<map>
const int MOD=1e9+7;
typedef long long ll;
map<pair<ll,ll>,int>v;
map<pair<ll,ll>,int>::iterator it;
int gcd(ll x,ll y){return y==0?x:gcd(y,x%y);}
int main()
{
ll c;
int cas=0;
while(scanf("%lld",&c)!=EOF&&c)
{
v.clear();
ll m=sqrt(c);
for(ll i=1;i<=m;i++)
{
ll j=sqrt(c-i*i);
if(j*j+i*i!=c||j<=i)continue;
ll x=j*j-i*i;
ll y=2*j*i;
if(x>y)swap(x,y);
if(gcd(x,y)!=1||gcd(x,c)!=1||gcd(c,y)!=1)continue;
if(v[make_pair(x,y)])continue;
v[make_pair(x,y)]=1;
}
if(cas)printf("\n");
printf("Case %d:\n",++cas);
printf("There are %d solution(s).\n",v.size());
for(it=v.begin();it!=v.end();it++)printf("%lld^2 + %lld^2 = %lld^2\n",it->first.first,it->first.second,c);
}
return 0;
}1503: 点到圆弧的距离
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
const double PI = acos(-1.0);
struct Point
{
double x,y;
friend Point operator - (Point a,Point b) //重载友元运算符
{
Point temp;
temp.x = a.x - b.x;
temp.y = a.y - b.y;
return temp;
}
};
Point p1, p2, p3, pc, pp;
double r;
Point get_pc1(Point p1, Point p2, Point p3) //求圆心
{
double a, b, c, d, e, f;
Point p;
a = 2*(p2.x-p1.x);
b = 2*(p2.y-p1.y);
c = p2.x*p2.x+p2.y*p2.y-p1.x*p1.x-p1.y*p1.y;
d = 2*(p3.x-p2.x);
e = 2*(p3.y-p2.y);
f = p3.x*p3.x+p3.y*p3.y-p2.x*p2.x-p2.y*p2.y;
p.x = (b*f-e*c)/(b*d-e*a);
p.y = (d*c-a*f)/(b*d-e*a);
r = sqrt((p.x-p1.x)*(p.x-p1.x)+(p.y-p1.y)*(p.y-p1.y));//半径
return p;
}
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 mult_cha(Point p1,Point p2) //叉积
{
return p1.x * p2.y - p2.x * p1.y;
}
double get_ans(Point pc,Point pp,Point p1,Point p2,Point p3)
{
double temp = mult_cha(p2-p1,p3-p1);//判断给点方向是顺时针还是逆时针
double f1 = atan2((p1-pc).y,(p1-pc).x);//和x正半轴的夹角
double f2 = atan2((p2-pc).y,(p2-pc).x);
double f3 = atan2((p3-pc).y,(p3-pc).x);
double f4 = atan2((pp-pc).y,(pp-pc).x);
double ans1 = fabs(dis(pp,pc) - r);//到圆心减去半径
double ans2 = min(dis(pp,p1),dis(pp,p3));//取到端点的较小值
if(temp < 0) //顺时针给点
{
if(f1 < f3) //判断区间方向，向下凹
{
if((f2 >= f1 && f2 <= f3) == (f4 >= f1 && f4 <= f3) )//p点和p2点在同一个区间
return ans1;
else //p点和p2点不在同一个区间
return ans2;
}
else//向上凸
{
if((f2 >= f3 && f2 <= f1) == (f4 >=f3 && f4 <= f1) )
return ans1;
else
return ans2;
}
}
else
{
if(f1 > f3)
{
if((f2 <= f1 && f2 >= f3) == (f4 <= f1 && f4 >= f3) )
return ans1;
else
return ans2;
}
else
{
if((f2 <= f3 && f2 >= f1) == (f4 <= f3 && f4 >= f1) )
return ans1;
else
return ans2;
}
}
}
int main()
{
int cas = 0;
while(~scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y,&p3.x,&p3.y,&pp.x,&pp.y))
{
pc = get_pc1(p1,p2,p3);//圆心
double ans = get_ans(pc,pp,p1,p2,p3);
printf("Case %d: %.3lf\n",++cas,ans);
}
return 0;
}
1506: Double Shortest Paths
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
//点的总数为 N，点的编号 1~N
const int MAXN = 10000;
const int MAXM = 100000;
const int INF = 0x3f3f3f3f;
struct Edge
{
int to, next, cap, flow, cost;
} edge[MAXM];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N, M;
void init(int n)
{
N = n;
tol = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost)
{
edge[tol]. to = v;
edge[tol]. cap = cap;
edge[tol]. cost = cost;
edge[tol]. flow = 0;
edge[tol]. next = head[u];
head[u] = tol++;
edge[tol]. to = u;
edge[tol]. cap = 0;
edge[tol]. cost = -cost;
edge[tol]. flow = 0;
edge[tol]. next = head[v];
head[v] = tol++;
}
bool spfa(int s, int t)
{
queue<int>q;
for(int i = 0; i < N; i++)
{
dis[i] = INF;
vis[i] = false;
pre[i] = -1;
}
dis[s] = 0;
vis[s] = true;
q.push(s);
while(!q.empty())
{
int u = q.front();
q.pop();
vis[u] = false;
for(int i = head[u]; i != -1; i = edge[i]. next)
{
int v = edge[i]. to;
if(edge[i]. cap > edge[i]. flow &&
dis[v] > dis[u] + edge[i]. cost )
{
dis[v] = dis[u] + edge[i]. cost;
pre[v] = i;
if(!vis[v])
{
vis[v] = true;
q.push(v);
}
}
}
}
if(pre[t] == -1) return false;
else return true;
}
//返回的是最大流， cost存的是最小费用
int minCostMaxflow(int s, int t, int &cost)
{
int flow = 0;
cost = 0;
while(spfa(s,t))
{
int Min = INF;
for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
{
if(Min > edge[i]. cap - edge[i]. flow)
Min = edge[i]. cap - edge[i]. flow;
}
for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
{
edge[i]. flow += Min;
edge[i^1]. flow -= Min;
cost += edge[i]. cost * Min;
}
flow += Min;
}
return flow;
}
int main()
{
int n, m;
int u, v, cost1, cost2;
int cas = 0;
while(~scanf("%d%d",&n,&m))
{
init(n+2);//注意
for(int i = 0; i < m; i++)
{
scanf("%d%d%d%d",&u,&v,&cost1,&cost2);
addedge(u,v,1,cost1);//流量为1
addedge(u,v,1,cost1+cost2);
}
//添加一个总的起点，一个终点，使编号从0~n
addedge(0,1,2,0);//流量为2,费用为0
addedge(n,n+1,2,0);
int ans = 0;
minCostMaxflow(0,n+1,ans);
printf("Case %d: %d\n",++cas,ans);
}
return 0;
}
1508: 地图的四着色
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
int n,m,cnt;
int vis[25][25];
long long ans;
char s[25][25];
int dir[4][2]= {-1,0,0,-1,1,0,0,1};
int ma[35][35],flag[35][35];
int color[35];
struct Node
{
int x,y;
};
struct Edge
{
int v,next;
} edge[2000];
int head[35],num;
void addedge(int u,int v)
{
edge[num].v=v;
edge[num].next=head[u];
head[u]=num++;
}
void bfs(int x,int y)
{
cnt++;
queue<Node>que;
Node a,next;
a.x=x,a.y=y;
que.push(a);
while(!que.empty())
{
Node now=que.front();
que.pop();
vis[now.x][now.y]=cnt;
for(int i=0; i<4; i++)
{
next.x=now.x+dir[i][0];
next.y=now.y+dir[i][1];
if(next.x<0||next.y<0||next.x>=n||next.y>=m||vis[next.x][next.y]||s[next.x][next.y]!=s[x][y]) continue;
que.push(next);
}
}
}
void bfs1(int x,int y)
{
queue<Node>que;
Node a,next;
a.x=x,a.y=y;
que.push(a);
while(!que.empty())
{
Node now=que.front();
que.pop();
flag[now.x][now.y]=1;
for(int i=0; i<4; i++)
{
next.x=now.x+dir[i][0];
next.y=now.y+dir[i][1];
if(next.x<0||next.y<0||next.x>=n||next.y>=m) continue;
if(vis[next.x][next.y]!=vis[x][y])
{
ma[vis[x][y]][vis[next.x][next.y]]=ma[vis[next.x][next.y]][vis[x][y]]=1;
continue;
}
if(flag[next.x][next.y]) continue;
que.push(next);
}
}
}
void init()
{
ans=cnt=0;
memset(vis,0,sizeof(vis));
for(int i=0; i<n; i++)
for(int j=0; j<m; j++)
if(!vis[i][j])
bfs(i,j);
memset(ma,0,sizeof(ma));
memset(flag,0,sizeof(flag));
for(int i=0; i<n; i++)
for(int j=0; j<m; j++)
if(!flag[i][j])
bfs1(i,j);
memset(head,-1,sizeof(head));
num=0;
for(int i=1; i<=cnt; i++)
for(int j=1; j<i; j++)
if(ma[i][j])
addedge(i,j);
}
int check(int pos,int k)
{
for(int i=head[pos]; i!=-1; i=edge[i].next)
if(color[edge[i].v]==k)
return 0;
return 1;
}
void dfs(int pos,int a0,int a1,int a2,int a3)///涂到第几个城市，四种颜色分别涂了几个
{
if(pos==cnt+1)
{
if(a0&&a1&&a2&&a3) ans++;
return;
}
color[pos]=0;
if(check(pos,0)) dfs(pos+1,a0+1,a1,a2,a3);
color[pos]=1;
if(a0&&check(pos,1)) dfs(pos+1,a0,a1+1,a2,a3);
color[pos]=2;
if(a2+a3<5&&check(pos,2)) dfs(pos+1,a0,a1,a2+1,a3);
color[pos]=3;
if(a2&&a2+a3<5&&check(pos,3)) dfs(pos+1,a0,a1,a2,a3+1);
}
int main()
{
int cas=1;
while(~scanf("%d %d",&n,&m))
{
for(int i=0; i<n; i++)
scanf("%s",s[i]);
init();
ans=0;
dfs(1,0,0,0,0);
printf("Case %d: %lld\n",cas++,4*ans);
}
return 0;
}
1510: Happy Robot
#include<iostream>
#include<cstring>
#include<cstdio>
#define INF 9999
using namespace std;
char str[1050];
int Min(int a,int b,int c)
{
if(a>b)
a=b;
if(a>c)
a=c;
return a;
}
int Max(int a,int b,int c)
{
if(a<b)
a=b;
if(a<c)
a=c;
return a;
}
void change(int* t,int dir)
{
int tt=t[0];
if(dir)
{
t[0]=t[3];
t[3]=t[1];
t[1]=t[2];
t[2]=tt;
}
else
{
t[0]=t[2];
t[2]=t[1];
t[1]=t[3];
t[3]=tt;
}
}
int main()
{
int len;
int t[4];
int Case=1;
while(~scanf("%s",str))
{
int a[4]= {0,-INF,-INF,-INF};
int b[4]= {0,INF,INF,INF};
int c[4]= {0,-INF,-INF,-INF};
int d[4]= {0,INF,INF,INF};
len=strlen(str);
for(int i=0; i<len; i++)
{
if(str[i]=='F')
{
a[0]++,a[1]--;
b[0]++,b[1]--;
c[2]++,c[3]--;
d[2]++,d[3]--;
}
else if(str[i]=='L')
{
change(a,1);
change(b,1);
change(c,1);
change(d,1);
}
else if(str[i]=='R')
{
change(a,0);
change(b,0);
change(c,0);
change(d,0);
}
else
{
t[0]=Max(a[0]+1,a[2],a[3]);
t[1]=Max(a[1]-1,a[2],a[3]);
t[2]=Max(a[0],a[1],a[2]);
t[3]=Max(a[0],a[1],a[3]);
memcpy(a,t,16);
t[0]=Min(b[0]+1,b[2],b[3]);
t[1]=Min(b[1]-1,b[2],b[3]);
t[2]=Min(b[0],b[1],b[2]);
t[3]=Min(b[0],b[1],b[3]);
memcpy(b,t,16);
t[0]=Max(c[0],c[2],c[3]);
t[1]=Max(c[1],c[2],c[3]);
t[2]=Max(c[0],c[1],c[2]+1);
t[3]=Max(c[0],c[1],c[3]-1);
memcpy(c,t,16);
t[0]=Min(d[0],d[2],d[3]);
t[1]=Min(d[1],d[2],d[3]);
t[2]=Min(d[0],d[1],d[2]+1);
t[3]=Min(d[0],d[1],d[3]-1);
memcpy(d,t,16);
}
}
t[0]=max(Max(a[0],a[1],a[2]),a[3]);
t[1]=min(Min(b[0],b[1],b[2]),b[3]);
t[2]=max(Max(c[0],c[1],c[2]),c[3]);
t[3]=min(Min(d[0],d[1],d[2]),d[3]);
printf("Case %d: %d %d %d %d\n",Case++,t[1],t[0],t[3],t[2]);
}
return 0;
}
1511: 残缺的棋盘
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
int r1,c1,r2,c2,r3,c3,head,flag,tail,tx,ty;
int vis[9][9];
int dx[8]={-1,-1,-1,0,0,1,1,1};
int dy[8]={-1,0,1,-1,1,-1,0,1};
int cnt=0;
struct node
{
int x,y,f,s;
}a[200];
void bfs()
{
head=1;
tail=1;
flag=0;
a[tail].x=r1;
a[tail].y=c1;
a[tail].s=0;
tail++;
while(head<tail)
{
for(int k=0;k<8;k++)
{
tx=a[head].x+dx[k];
ty=a[head].y+dy[k];
if(tx==r3&&ty==c3||tx<1||ty<1||tx>8||ty>8)
continue;
if(vis[tx][ty]==0)
{
vis[tx][ty]=1;
a[tail].x=tx;
a[tail].y=ty;
a[tail].s=a[head].s+1;
tail++;
}
if(tx==r2&&ty==c2)
{
flag=1;
break;
}
//cout<<tail<<endl;
}
if(flag)
break;
head++;
}
cout<<"Case "<<++cnt<<": "<<a[tail-1].s<<endl;
}
int main()
{
int T=10010;
while(scanf ("%d%d%d%d%d%d",&r1,&c1,&r2,&c2,&r3,&c3)==6)
{
memset(vis,0,sizeof(vis));
vis[r1][c1]=1;
bfs();
}
return 0;
}1513: Kick the ball!
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
double p[11];
int a,b;
double ans;
void dfs(int x,int y,int k,double pl )
{
if(pl<1e-6) return;
if(k==10)
{
if(x==a&&y==b) ans+=pl;
return;
}
if(y+(5-k/2)<x||x+(5-(k+1)/2)<y)//判断结束
{
dfs(x,y,k+1,pl);
return;
}
if(k%2==0)//我
{
dfs(x+1,y,k+1,pl*p[k]);//球进
dfs(x,y,k+1,pl*(1-p[k]));//不进
}
else//他
{
dfs(x,y+1,k+1,pl*p[k]);
dfs(x,y,k+1,pl*(1-p[k]));
}
}
int main()
{
int num=1;
while(scanf("%lf",&p[0])!=EOF)
{
ans=0;
for(int i=1;i<5;i++)
scanf("%lf",&p[2*i]);
for(int i=0;i<5;i++)
scanf("%lf",&p[2*i+1]);
scanf("%d-%d",&a,&b);
dfs(0,0,0,1.0);
printf("Case %d: %.2f%%\n",num++,100*ans);
}
return 0;
}1514: Packs
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <sstream>
#include <iomanip>
using namespace std;
typedef long long LL;
const long long INF=99999999999999999LL;
const int EXP=1e-5;
const int MS=42;
map<LL,LL> mp;
int n;
LL W;
LL w[MS],v[MS];
void solve()
{
mp.clear();
int n1=n/2;
for(int i=0;i<(1<<n1);i++)
{
LL sw=0,sv=0;
for(int j=0;j<n1;j++)
{
if((i>>j)&1)
{
sw+=w[j];
sv+=v[j];
}
}
mp[sw]=max(mp[sw],sv);
}
LL ans=-INF;
for(int i=0;i< 1<<(n-n1);i++)
{
LL sw=0,sv=0;
for(int j=0;j<(n-n1);j++)
{
if((i>>j)&1)
{
sw+=w[n1+j];
sv+=v[n1+j];
}
}
if(mp.count(W-sw))
ans=max(ans,mp[W-sw]+sv);
}
printf("%lld\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%lld",&n,&W);
for(int i=0;i<n;i++)
scanf("%lld%lld",&w[i],&v[i]);
solve();
}
return 0;
}1526: Beam me out!
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <map>
#include <vector>
template <class T>
inline bool rd(T &ret) {
char c; int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c<'0' || c>'9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void pt(T x) {
if (x <0) {
putchar('-');
x = -x;
}
if (x>9) pt(x / 10);
putchar(x % 10 + '0');
}
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 50500;
const int inf = 1e8;
//N为最大点数
const int M = 7500000;
//M为最大边数
int n;//n m 为点数和边数
struct Edge{
int from, to, nex;
bool sign;//是否为桥
}edge[M];
int head[N], edgenum;
void add(int u, int v){//边的起点和终点
Edge E = { u, v, head[u], false };
edge[edgenum] = E;
head[u] = edgenum++;
}
int DFN[N], Low[N], Stack[N], top, Time; //Low[u]是点集{u点及以u点为根的子树} 中(所有反向弧)能指向的(离根最近的祖先v) 的DFN[v]值(即v点时间戳)
int taj;//连通分支标号，从1开始
int Belong[N];//Belong[i] 表示i点属于的连通分支
bool Instack[N];
vector<int> bcc[N]; //标号从1开始
void tarjan(int u, int fa){
DFN[u] = Low[u] = ++Time;
Stack[top++] = u;
Instack[u] = 1;
for (int i = head[u]; ~i; i = edge[i].nex){
int v = edge[i].to;
if (DFN[v] == -1)
{
tarjan(v, u);
Low[u] = min(Low[u], Low[v]);
if (DFN[u] < Low[v])
{
edge[i].sign = 1;//为割桥
}
}
else if (Instack[v]) Low[u] = min(Low[u], DFN[v]);
}
if (Low[u] == DFN[u]){
int now;
taj++; bcc[taj].clear();
do{
now = Stack[--top];
Instack[now] = 0;
Belong[now] = taj;
bcc[taj].push_back(now);
} while (now != u);
}
}
void tarjan_init(int all){
memset(DFN, -1, sizeof(DFN));
memset(Instack, 0, sizeof(Instack));
top = Time = taj = 0;
for (int i = 1; i <= all; i++)if (DFN[i] == -1)tarjan(i, i); //注意开始点标！！！
}
vector<int>G[N];
int du[N], hehe[N];
bool itself[N];
void suodian(){
memset(du, 0, sizeof(du));
for (int i = 1; i <= taj; i++){
G[i].clear();
hehe[i] = false;
for (int j = 0; j < bcc[i].size(); j++)
if (itself[bcc[i][j]])hehe[i] = true;
}
for (int i = 0; i < edgenum; i++){
int u = Belong[edge[i].from], v = Belong[edge[i].to];
if (u != v)G[u].push_back(v), du[v]++;
}
}
void init(){ memset(head, -1, sizeof(head)); edgenum = 0; }
bool vis[N];
int siz, bad;
void bfs(){
memset(vis, 0, sizeof vis);
queue<int> q; q.push(Belong[1]);
vis[Belong[1]] = true;
siz = 0;
bad = 0;
while (!q.empty()){
int u = q.front(); q.pop();
// printf(" --%d\n", u);
if ((int)bcc[u].size() > 1 || hehe[u])siz++;
if ((int)G[u].size() == 0){
if (u != Belong[n])bad++;
}
for (int i = 0; i < G[u].size(); i++){
int v = G[u][i];
// printf(" **%d\n", v);
if (!vis[v]){
vis[v] = true;
q.push(v);
}
}
}
}
int main() {
while (cin >> n){
init();
for (int i = 1, num, j; i < n; i++){
itself[i] = false;
rd(num); while (num-->0){
rd(j), add(i, j);
if (j == i)itself[i] = true;
}
}
itself[n] = false;
tarjan_init(n);
suodian();
// for(int i = 1; i <= n; i++)printf("%d ", Belong[i]); puts("");
bfs();
// printf("leaf:%d siz:%d\n", leaf, siz);
if (vis[Belong[n]] && bad == 0) printf("PARDON ");
else printf("PRISON ");
!siz ? puts("LIMITED") : puts("UNLIMITED");
}
return 0;
}1527: Bounty Hunter
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <algorithm>
#include <stdlib.h>
using namespace std;
#define ll int
#define N 550
#define inf 1152921504606846976
struct node{
double x, y;
bool operator<(const node&a)const{
if(a.x==x)return a.y>y;
return a.x>x;
}
void put(){
printf("(%.0f, %.0f)\n", x, y);
}
}p[N];
double Dis(node a, node b){return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
int n;
double dis[N][N],dp[N][N];
int main(){
ll i, j, u, v; int T; scanf("%d", &T);
while(T-->0){
scanf("%d", &n);
for(i=1;i<=n;i++)scanf("%lf %lf",&p[i].x,&p[i].y);
sort(p+1,p+n+1);
// for(int i = 1; i <= n; i++)p[i].put();
for(i=1;i<=n;i++)for(j=1;j<=n;j++)dis[i][j] = Dis(p[i],p[j]), dp[i][j] = inf;
dp[1][1] = 0;
for(i=2;i<=n;i++)
{
for(j = 1;j < i; j++)
{
dp[i][j] = min(dp[i-1][j]+dis[i][i-1], dp[i][j]);
dp[i][i-1] = min(dp[i-1][j]+dis[j][i], dp[i][i-1]);
}
}
printf("%.10f\n",dp[n][n-1]+dis[n][n-1]);
}
return 0;
}1529: Equator
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int INF = 1e5;
const int maxn = 1e6+5;
int a[maxn*2], sum[maxn*2];
int deq[maxn*2];
int main()
{
//freopen("in", "r", stdin);
int T;
scanf("%d", &T);
while(T--) {
int n;
scanf("%d", &n);
sum[0] = 0;
for(int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i+n] = a[i];
sum[i] = sum[i-1] + a[i];
}
for(int i = n+1; i <= 2*n; ++i) {
sum[i] = sum[i-1] + a[i];
}
int ans = 0;
deq[0] = 0;
int s = 0, t = -1;
for(int i = 1; i <= 2*n; ++i) {
while(s <= t && sum[i] < sum[deq[t]]) {
ans = max(ans, sum[deq[t]] - sum[deq[s]]);
t--;
}
while(s <= t && i - deq[s] > n) {
ans = max(ans, sum[deq[t]] - sum[deq[s]]);
s++;
}
deq[++t] = i;
}
ans = max(ans, sum[deq[t]] - sum[deq[s]]);
printf("%d\n", ans);
}
return 0;
}
1531: Jewelry Exhibition
#include<stdio.h>
#include<string.h>
const int maxn = 1e4+5;
int cas;
int n, m, k;
bool link[maxn][maxn], used[maxn];
int res[maxn];
bool find(int x)
{
for(int i = 0;i<m;i++)
{
if(link[x][i] == true && used[i] == false)
{
used[i] = true;
if(res[i] == -1 || find(res[i]))
{
res[i] = x;
return true;
}
}
}
return false;
}
int main()
{
scanf("%d", &cas);
while(cas--)
{
int sum = 0;
memset(link, false, sizeof link);
memset(res, -1, sizeof res);
scanf("%d%d%d", &n, &m, &k);
while(k--)
{
double x, y;
scanf("%lf%lf", &x, &y);
link[(int)x][(int)y] = true;
}
for(int i = 0;i<n;i++)
{
memset(used, false, sizeof used);
if(find(i))
sum++;
}
printf("%d\n", sum);
}
return 0;
}1532: JuQueen
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdlib>
#include<set>
#include<queue>
#include<stack>
#include<vector>
#include<map>
#define N 4587530
#define Mod 10000007
#define lson l,mid,idx<<1
#define rson mid+1,r,idx<<1|1
#define lc idx<<1
#define rc idx<<1|1
const double EPS = 1e-11;
const double PI = acos ( -1.0 );
const double E = 2.718281828;
typedef long long ll;
const int INF = 100010;
using namespace std;
struct node {
int Max;
int Min;
int se;
} tree[N<<2];
int n,c,q;
int Max,Min;
void push_up(int idx) {
tree[idx].Max=max(tree[lc].Max,tree[rc].Max);
tree[idx].Min=min(tree[lc].Min,tree[rc].Min);
}
void build(int l,int r,int idx) {
tree[idx].se=0;
if(l==r) {
tree[idx].Max=0;
tree[idx].Min=0;
return;
}
int mid=(l+r)>>1;
build(lson);
build(rson);
push_up(idx);
}
void push_down(int idx) {
if(tree[idx].se) {
tree[lc].se+=tree[idx].se;
tree[rc].se+=tree[idx].se;
tree[lc].Max+=tree[idx].se;
tree[lc].Min+=tree[idx].se;
tree[rc].Max+=tree[idx].se;
tree[rc].Min+=tree[idx].se;
tree[idx].se=0;
}
}
void updata(int l,int r,int idx,int x,int y,int val) {
if(l>=x&&r<=y) {
tree[idx].Max+=val;
tree[idx].Min+=val;
tree[idx].se+=val;
return;
}
push_down(idx);
int mid=(l+r)>>1;
if(x<=mid)updata(lson,x,y,val);
if(y>mid)updata(rson,x,y,val);
push_up(idx);
}
int query(int l,int r,int idx,int x,int y) {
if(l>=x&&r<=y) {
Min=min(tree[idx].Min,Min);
return tree[idx].Max;
}
push_down(idx);
int mid=(l+r)>>1;
int res=0;
if(x<=mid)res=max(res,query(lson,x,y));
if(y>mid)res=max(res,query(rson,x,y));
return res;
}
int main() {
//freopen("in.txt","r",stdin);
while(~scanf("%d%d%d",&c,&n,&q)) {
char s[20];
int l,r,val;
build(1,c,1);
while(q--) {
scanf("%s",s);
if(s[0]=='s') {
scanf("%d",&l);
printf("%d\n",query(1,c,1,l+1,l+1));
} else if(s[0]=='g') {
scanf("%d%d%d",&l,&r,&val);
Min=INF;
if(val==0) {
printf("0\n");
continue;
}
int x=query(1,c,1,l+1,r+1);
// printf("x=%d\n",x);
if(val>0) {
if(n-x>=val) {
printf("%d\n",val);
updata(1,c,1,l+1,r+1,val);
} else {
printf("%d\n",n-x);
updata(1,c,1,l+1,r+1,n-x);
}
} else {
int v=-val;
if(Min>=v) {
printf("%d\n",val);
updata(1,c,1,l+1,r+1,val);
} else {
printf("%d\n",-1*Min);
updata(1,c,1,l+1,r+1,-1*Min);
}
}
} else {
scanf("%d%d",&l,&val);
if(val==0) {
printf("0\n");
continue;
}
Min=INF;
int x=query(1,c,1,l+1,l+1);
if(val>0) {
if(n-x>=val) {
printf("%d\n",val);
updata(1,c,1,l+1,l+1,val);
} else {
printf("%d\n",n-x);
updata(1,c,1,l+1,l+1,n-x);
}
} else {
int v=-val;
if(Min>=v) {
printf("%d\n",val);
updata(1,c,1,l+1,l+1,val);
} else {
printf("%d\n",-1*Min);
updata(1,c,1,l+1,l+1,-1*Min);
}
}
}
}
}
return 0;
}
1534: Not a subsequence
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
const int N = 1e6+1000;
const int MOD = 1E9+7;
int n,m;
int last[200];
int tmp0[N],tmp1[N];
int *f=tmp0+1;
int *dp=tmp1+1,mf[N],mdp[2];
int v[N];
char str[N];
int main(){
int i,j;
int nn;
scanf("%d",&nn);
while(nn--){
scanf("%d",&j);
f[0] = j;
n = 0;
scanf("%s",str+1);
n = strlen(str+1);
//clear1
for(i=1;i<=199;i++) last[i]=0;
//clear2
while(mdp[0]<=mdp[1]){
v[mdp[0]]=mf[mdp[0]]=0;
mdp[0]++;
}
mdp[0]=mdp[1]=0;
f[-1] = 1;
dp[-1]=0;
f[0]=j;
dp[0]=1;
mf[dp[-1]] = j*f[-1];
v[dp[-1]] = j;
for(i=1;i<=n;i++){
int l = last[str[i]];
//remove
mf[dp[l-1]]=(mf[dp[l-1]]-f[l-1])%MOD;
v[dp[l-1]]--;
//add
mf[dp[i-1]]=(mf[dp[i-1]]+f[i-1])%MOD;
v[dp[i-1]]++;
if(dp[i-1] > mdp[1])mdp[1] = dp[i-1];
while(mdp[0]<mdp[1] && v[mdp[0]]==0)mdp[0]++;
//while(mdp[0]<mdp[1] && v[mdp[1]]==0)mdp[1]--;
dp[i]=mdp[0]+1;
f[i]=mf[mdp[0]];
if(dp[i] > mdp[1])mdp[1] = dp[i];
last[str[i]] = i;
}
if(f[n]<0)f[n]+=MOD;
cout << dp[n] << ' '<<f[n] << endl;
}
return 0;
}1535: Pizza voting
#include<cstdio>
using namespace std;
int main()
{
int n,p;
int c;
char s[105];
int low,high;
while(scanf("%d%d",&n,&p)==2)
{
low=1;
high=n;
for(int i=1; i<=n; i++)
{
scanf("%d%s",&c,s);
}
while(low!=high)
{
high-=1;
if(low==high)
break;
low+=1;
if(low==high)
break;
if(p-low==high-p)
low+=1;
else if(p-low<high-p)
high-=1;
else
low+=1;
}
if(low==p)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
1536: Bit String Reordering
#include<iostream>
#include<cstdio>
#include<cmath>
#include<queue>
#include<ctype.h>
#include<cstring>
#include<stdlib.h>
#include<algorithm>
using namespace std;
const int MAXN=20;
int n,m,result;
int a[MAXN],temp[MAXN],b[MAXN],vis[1000000];
struct node
{
int res;//01串代表的数字
int step;//步数
int num[MAXN];//01串
}s1,s2;
queue<node> Q;
int calc(int num[])
{
int ans=0,ok=1;
for(int i=n-1;i>=0;i--)
{
ans+=ok*num[i];
ok*=2;
}
return ans;
}
int BFS()
{
node now,next;
while(!Q.empty())
{
now=Q.front();
Q.pop();
if(now.res==result) return now.step;
for(int i=0;i<n;i++) next.num[i]=now.num[i];
for(int i=0;i<n-1;i++)
{
swap(next.num[i],next.num[i+1]);//交换相邻的两位生成新的01串
next.res=calc(next.num);
if(!vis[next.res])
{
vis[next.res]=1;
next.step=now.step+1;
Q.push(next);
}
swap(next.num[i],next.num[i+1]);
}
}
}
int main()
{
scanf("%d %d",&n,&m);
for(int i=0;i<n;i++) scanf("%d",&a[i]);
for(int i=0;i<m;i++) scanf("%d",&temp[i]);
int cnt=0,flag=1;
for(int i=0;i<m;i++)
{
for(int j=0;j<temp[i];j++)
s1.num[cnt++]=flag;
flag=!flag;
}
s1.res=calc(s1.num);
s1.step=0;
Q.push(s1);
vis[s1.res]=1;//初始化第一个起点串信息
cnt=0,flag=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<temp[i];j++)
s2.num[cnt++]=flag;
flag=!flag;
}
s2.res=calc(s2.num);
s2.step=0;
Q.push(s2);
vis[s2.res]=1;//初始化第二个起点串信息
result=calc(a);
int ans=BFS();
printf("%d\n",ans);
return 0;
}1537: Miscalculation
#include<iostream>
#include<cstdio>
#include<stack>
#include<cstring>
#include<string>
using namespace std;
const int N=105;
int main()
{
char c[N];
char c1[N];
int k;
stack<int> s;
while(~scanf("%s",c))
{
bool kk1=0,kk2=0;
cin>>k;
int len=strlen(c);
for(int i=0;i<len;i++)
{
if(i%2==0)
s.push(c[i]-'0');
else
{
if(c[i]=='*')
{
i++;
int temp=s.top();
temp*=c[i]-'0';
s.pop();
s.push(temp);
}
}
}
int ans=0;
while(!s.empty())
{
ans+=s.top();
s.pop();
}
if(ans==k)
kk1=1;
ans=c[0]-'0';
for(int i=1;i<len;i+=2)
{
if(c[i]=='*')
ans*=c[i+1]-'0';
else
ans+=c[i+1]-'0';
}
if(ans==k)
kk2=1;
if(kk1&&kk2)
cout<<"U"<<endl;
else if(!kk1&&kk2)
cout<<"L"<<endl;
else if(!kk1&&!kk2)
cout<<"I"<<endl;
else
cout<<"M"<<endl;
}
return 0;
}1538: Shopping
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=505;
struct node
{
int l,r;
bool operator <(const node& A) const
{
return l<A.l;
}
}a[N];
int n,m;
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i=0;i<m;i++)
{
scanf("%d%d",&a[i].l,&a[i].r);
}
sort(a,a+m);
int ans=n+1;
int maxv=a[0].r,minv=a[0].l;
for(int i=1;i<m;i++)
{
if(a[i].l>maxv)
{
ans+=2*(maxv-minv);
maxv=a[i].r;
minv=a[i].l;
}
else
maxv=max(maxv,a[i].r);
}
ans+=2*(maxv-minv);
cout<<ans<<endl;
}
return 0;
}1539: Space Golf
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#define maxn 20000
#define inf 0x3f3f3f
using namespace std;
struct node
{
double x,y;
}p[maxn];
double Min(double a,double b)
{
if(a>b) return b;
else return a;
}
double Max(double a,double b)
{
if(a>b) return a;
else
return b;
}
int main()
{
int n,b;
double d;
while(scanf("%lf%d%d",&d,&n,&b)!=EOF)
{
double m=inf;
for(int i=1;i<=n;i++)
scanf("%lf%lf",&p[i].x,&p[i].y);
for(int j=0;j<=b;j++)
{
double mi=0;
double l=d/(double)(j+1);
double miao=l/4.0;
double tmp=sqrt((l*l/(8.0*miao))+2*miao);
for(int i=1;i<=n;i++)
{
int tmp=p[i].x/l;
double xx=p[i].x-(double)tmp*l;
double ans1=(xx-l/2.0)*(xx-l/2.0);
ans1=(ans1*4.0)/(l*l);
ans1=1-ans1;
ans1=p[i].y/ans1;
double temp=sqrt((l*l/(8.0*ans1))+2*ans1);
mi=Max(ans1,mi);
}
mi=Max(mi,l/4.0);
double res=sqrt((l*l/(8.0*mi))+2*mi);
m=Min(m,res);
}
printf("%.6lf\n",m);
}
}
1541: There is No Alternative
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctype.h>
#include<queue>
#include<stack>
#include<stdlib.h>
#include<algorithm>
using namespace std;
const int MAXN=1000000+5;
int n,m,cnt,result,num;
struct node
{
int x,y,val;
bool operator<(const node A)const
{
return val<A.val;
}
}a[MAXN];
int p[500+5],b[MAXN],vis[MAXN];
int finfa(int x)
{
return p[x]==x?x:p[x]=finfa(p[x]);
}
void init()
{
for(int i=1;i<=n;i++) p[i]=i;
}
int kru(int flag)
{
int res=0;
for(int i=1;i<=m;i++)
{
if(vis[i]==1) continue;
int x=finfa(a[i].x);
int y=finfa(a[i].y);
if(x!=y)
{
p[x]=y;
res+=a[i].val;
if(flag==0) b[cnt++]=i;//分别用flag=0/1判断是不是第一次生成最小生成树，第一次要把每一条边记录下来
}
}
return res;
}
int main()
{
scanf("%d %d",&n,&m);
for(int i=1;i<=m;i++) scanf("%d %d %d",&a[i].x,&a[i].y,&a[i].val);
sort(a+1,a+m+1);
init();
cnt=0;
num=0;
result=0;
int ans=kru(0);
for(int i=0;i<cnt;i++)
{
init();
vis[b[i]]=1;
if(kru(1)!=ans)
{
result+=a[b[i]].val;
num++;
}
vis[b[i]]=0;
}
printf("%d %d\n",num,result);
return 0;
}1542: Flipping Parentheses
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<string>
#include<iostream>
#include<functional>
#include<algorithm>
using namespace std;
typedef long long LL;
typedef pair<LL, int> PLI;
const int MX = 3e5 + 5;
const int INF = 0x3f3f3f3f;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define root 1,n,1
char W[MX];
int MIN[MX << 2], F[MX << 2], col[MX << 2], A[MX];
void push_up(int rt) {
MIN[rt] = min(MIN[rt << 1], MIN[rt << 1 | 1]);
F[rt] = min(F[rt << 1], F[rt << 1 | 1]);
}
void push_down(int rt) {
if(col[rt]) {
col[rt << 1] += col[rt];
col[rt << 1 | 1] += col[rt];
MIN[rt << 1] += col[rt];
MIN[rt << 1 | 1] += col[rt];
F[rt << 1] += col[rt];
F[rt << 1 | 1] += col[rt];
col[rt] = 0;
}
}
void build(int l, int r, int rt) {
col[rt] = 0;
if(l == r) {
MIN[rt] = A[l];
F[rt] = A[l] - l;
return;
}
int m = (l + r) >> 1;
build(lson);
build(rson);
push_up(rt);
}
void update(int L, int R, int d, int l, int r, int rt) {
if(L <= l && r <= R) {
MIN[rt] += d;
F[rt] += d;
col[rt] += d;
return;
}
int m = (l + r) >> 1;
push_down(rt);
if(L <= m) update(L, R, d, lson);
if(R > m) update(L, R, d, rson);
push_up(rt);
}
int query_1(int l, int r, int rt) { //查询第一个)
if(l == r) {
return l;
}
int m = (l + r) >> 1;
push_down(rt);
if(F[rt << 1] < 0) return query_1(lson);
else return query_1(rson);
}
int query_2(int l, int r, int rt) {//查询一个位置，p,使[p+1,n]全部大于等于2
if(l == r) {
return l;
}
int m = (l + r) >> 1;
push_down(rt);
if(MIN[rt << 1 | 1] < 2) return query_2(rson);
else return query_2(lson);
}
int main() {
//freopen("input.txt", "r", stdin);
int n, Q, t, pos;
while(~scanf("%d%d", &n, &Q)) {
scanf("%s", W + 1);
int sum = 0;
for(int i = 1; i <= n; i++) {
sum += W[i] == '(' ? 1 : -1;
A[i] = sum;
}
build(root);
while(Q--) {
scanf("%d", &t);
if(W[t] == '(') {
W[t] = ')'; update(t, n, -2, root);
t = query_1(root); W[t] = '('; update(t, n, 2, root);
} else {
W[t] = '('; update(t, n, 2, root);
t = query_2(root) + 1; W[t] = ')'; update(t, n, -2, root);
}
printf("%d\n", t);
}
}
}1547: Rectangle
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e4 + 10;
int width[N], dp[N];
int main() {
//freopen("in.txt", "r", stdin);
int T, n;
int a, b;
scanf("%d", &T);
while(T--) {
scanf("%d", &n);
int ans = 0, cnt = 0;
int sum = 0;
for(int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
if(a == 2) {
ans += b;
}else {
width[cnt++] = b;
sum += b;
}
}
sort(width, width + cnt);
memset(dp, 0, sizeof(dp));
for(int i = 0; i < cnt; i++) {
for(int j = sum/2; j >= width[i]; j--) {
dp[j] = max(dp[j], dp[j-width[i]] + width[i]);
}
}
printf("%d\n", ans + max(dp[sum/2], sum-dp[sum/2]));
}
return 0;
}1548: Design road
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
using namespace std;
const double AC=1e-6;
const int M=1005;
double fu(double yw,double x,double y,double ri,double c1,double c2)//这里早用double早就过了
{
double ww=(double)c2*sqrt(ri*ri+yw*yw);
double wr=(double)c1*sqrt((y-yw)*(y-yw)+(x-ri)*(x-ri));
return ww+wr;
}
double ts(int x,int y,int ri,int c1,int c2)
{
double lo=0,hi=y;
double mid,midmid;
while(lo+AC<hi)
{
mid=(hi+lo)/2.0;
midmid=(mid+hi)/2.0;
//cout<<lo<<" "<<hi<<" "<<mid<<" "<<midmid<<" "<<fu(mid,x,y,ri,c1,c2)<<endl;
if(fu(mid,x,y,ri,c1,c2)>=fu(midmid,x,y,ri,c1,c2))
lo=mid;
else
hi=midmid;
}
return mid;
}
int main()
{
int n,x,y,c1,c2;
int river,rx,rw;
while(scanf("%d%d%d%d%d",&n,&x,&y,&c1,&c2)!=EOF)
{
river=0;
for(int i=0;i<n;i++)
{
scanf("%d%d",&rx,&rw);
river+=rw;
}
printf("%.2lf\n",fu(ts(x,y,river,c1,c2),x,y,river,c1,c2));
}
return 0;
}
1549: Navigition Problem
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <algorithm>
using namespace std;
const int N = 1005;
struct Point
{
double x,y;
} p[N];
struct Line
{
Point a,b;
} line[N];
double len[N];
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 sum[N];
int main()
{
int n;
double d;
while(scanf("%d%lf",&n,&d)!=EOF)
{
double SUM = 0;
sum[0] = 0;
for(int i=1; i<=n+1; i++)
{
scanf("%lf%lf",&p[i].x,&p[i].y);
if(i>1)
{
len[i-1] = dis(p[i],p[i-1]);
SUM+=len[i-1];
sum[i-1] = sum[i-2]+len[i-1];
}
}
if(SUM<d)
{
printf("No Such Points.\n");
continue;
}
double now = 0,k,x,y;
for(int i=1; i<=n;)
{
if(now+d<=sum[i])
{
double L = now+d - sum[i-1];
double x1 = p[i].x,y1 = p[i].y;
double x2 = p[i+1].x,y2 = p[i+1].y;
if(x1!=x2)
{
k = (y1-y2)/(x1-x2);
if(x2<x1)
{
x = x1-sqrt((L*L)/(k*k+1));
y = k*(x-x1)+y1;
}
else
{
x = x1+sqrt((L*L)/(k*k+1));
y = k*(x-x1)+y1;
}
}
else
{
x = x1;
if(y2<y1) y = y1-L;
else y = y1+L;
}
printf("%.2lf,%.2lf\n",x,y);
now = now+d;
}
else
{
i++;
}
}
}
}1550: Simple String
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
int A[26], B[26], C[26];
bool flag[26];
char str[200002];
int main()
{
int i, lenth;
while (cin >> str)
{
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
memset(C, 0, sizeof(C));
lenth = strlen(str);
for (i=0; i<lenth; i++)
{
A[str[i]-'A']++;//统计A字符串中某个字母的个数
}
cin >> str;
for (i=0; i<lenth; i++)
{
B[str[i]-'A']++;//统计B字符串中字母的个数
}
cin >> str;
for (i=0; i<lenth; i++)
{
C[str[i]-'A']++;
}
memset(flag, true, sizeof(flag));
for (i=0; i<26; i++)
{
if (A[i] > lenth/2)
{
A[i] = lenth/2; //当A中某个字母>N中，最多也只能提供N个，赋值为N
}
if (B[i] > lenth/2)
{
B[i] = lenth/2;
}
if (C[i] <= A[i] + B[i])//当c字符串满足是，标记为false
{
flag[i] = false;
}
}
for (i=0; i<26; i++)
{
if (flag[i] == true)//c字符串中有一个不满足，跳出循环
{
break;
}
}
if (i<26)
{
cout << "NO" << endl;
}
else
{
cout << "YES" << endl;
}
}
return 0;
}1551: Longest Increasing Subsequence Again
#include<stdio.h>
#include<algorithm>
using namespace std;
const int N = 10005;
struct qj
{
int l,r;
}kuai[N];
int b[N],tn,n,a[N],k[N],tree[N*4];
void builde(int l,int r,int e)
{
int m=(l+r)/2;
tree[e]=0;
if(l==r)
return ;
builde(l,m,e*2);
builde(m+1,r,e*2+1);
}
void settree(int l,int r,int e,int id,int ans)
{
int m=(l+r)/2;
if(tree[e]<ans)
tree[e]=ans;
if(l==r)
{
return ;
}
if(id<=m)
settree(l,m,e*2,id,ans);
else
settree(m+1,r,e*2+1,id,ans);
}
int findans(int l,int r,int e,int id)
{
int m=(l+r)/2,ans=0;
if(l==r)
return 0;
if(id<=m)
{
ans=findans(l,m,e*2,id);
if(ans<tree[e*2+1])
ans=tree[e*2+1];
return ans;
}
else
return findans(m+1,r,e*2+1,id);
}
int cmp(int aa,int bb)
{
return aa<bb;
}
void cut()
{
tn=1;
sort(b+1,b+1+n,cmp);
for(int i=2;i<=n;i++)
if(b[i]!=b[tn])
b[++tn]=b[i];
}
int two(int aa)
{
int l,r,m;
l=1;r=tn;
while(l<=r)
{
m=(l+r)/2;
if(b[m]==aa)
return m;
if(b[m]>aa)
r=m-1;
else l=m+1;
}
return m;
}
int main()
{
while(scanf("%d",&n)>0)
{
if(n==0)
{
printf("0\n");continue;
}
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
b[i]=a[i];
}
cut();
builde(1,tn,1);
int m=1;
kuai[m].l=kuai[m].r=1;
for(int i=2;i<=n;i++)
if(a[kuai[m].r]>=a[i])
{
m++; kuai[m].l=kuai[m].r=i;
}
else
kuai[m].r++;
for(int i=1;i<=m;i++)
{
for(int j=kuai[i].r;j>=kuai[i].l;j--)
k[j]=kuai[i].r-j+1;
}
int ans=0;
for(int i=m;i>0;i--)
{
int aaa,id;
for(int j=kuai[i].r;j>=kuai[i].l;j--)
{
id=two(a[j]);
aaa=j-kuai[i].l+1;
aaa+=findans(1,tn,1,id);
if(ans<aaa)
ans=aaa;
}
for(int j=kuai[i].r;j>=kuai[i].l;j--)
{
id=two(a[j]);
settree(1,tn,1,id,k[j]);
}
}
printf("%d\n",ans);
}
}
1552: Friends
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string.h>
#include <cstdlib>
#include <time.h>
#define ll long long
using namespace std;
ll MIN;
ll mult_mod(ll a,ll b,ll n)
{
ll s=0;
while(b)
{
if(b&1) s=(s+a)%n;
a=(a+a)%n;
b>>=1;
}
return s;
}
ll pow_mod(ll a,ll b,ll n)
{
ll s=1;
while(b)
{
if(b&1) s=mult_mod(s,a,n);
a=mult_mod(a,a,n);
b>>=1;
}
return s;
}
int Prime(ll n)
{
ll u=n-1,pre,x;
int i,j,k=0;
if(n==2||n==3||n==5||n==7||n==11) return 1;
if(n==1||(!(n%2))||(!(n%3))||(!(n%5))||(!(n%7))||(!(n%11))) return 0;
for(;!(u&1);k++,u>>=1);
srand((ll)time(0));
for(i=0;i<5;i++)
{
x=rand()%(n-2)+2;
x=pow_mod(x,u,n);
pre=x;
for(j=0;j<k;j++)
{
x=mult_mod(x,x,n);
if(x==1&&pre!=1&&pre!=(n-1))
return 0;
pre=x;
}
if(x!=1) return 0;
}
return 1;
}
int N;
int mp[110][110];
int linker[110];
int vis[110];
int ans;
bool dfs(int u)
{
for(int i=0;i<N;i++)
{
if(mp[u][i]&&!vis[i])
{
vis[i]=1;
if(linker[i]==-1||dfs(linker[i]))
{
linker[i]=u;
return 1;
}
}
}
return 0;
}
void hungary()
{
memset(linker,-1,sizeof(linker));
for(int i=0;i<N;i++)
{
memset(vis,0,sizeof(vis));
if(dfs(i))
{
ans++;
}
}
}
ll A[110];
int main()
{
while(scanf("%d",&N)!=EOF)
{
for(int i=0;i<N;i++)
{
scanf("%lld",&A[i]);
}
memset(mp,0,sizeof(mp));
for(int i=0;i<N;i++)
for(int j=i+1;j<N;j++)
{
if(Prime(A[i]+A[j]))
mp[i][j]= mp[j][i] =1;
}
ans=0;
hungary();
printf("%d\n",ans/2);
}
return 0;
}
1553: Good subsequence
#include <stdio.h>
#include <stdlib.h>
#define N 10010
#define inf 0x3f3f3f3f
int a[N];
int main()
{
int n,k;
while(~scanf("%d%d",&n,&k))
{
int i,j;
for(i=0; i<n; i++)
{
scanf("%d",&a[i]);
}
int max1,min1,ans=0;
for(i=0; i<n; i++)
{
min1=inf,max1=0;
for(j=i; j<n; j++)
{
if(max1<a[j])
max1=a[j];
if(min1>a[j])
min1=a[j];
if((max1-min1)<=k&&ans<(j-i+1))
{
ans=j-i+1;
}
else if((max1-min1)>k)这是一个重要的剪枝
{
break;
}
}
}
printf("%d\n",ans);
}
return 0;
}
1554: SG Value
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#define Mod 1000000007
#define ll long long
#define N 1100
#define INF 1010010010
using namespace std;
int n;
int main() {
//freopen("in.txt","r",stdin);
while(~scanf("%d",&n)) {
int op,x;
ll ans=1;
priority_queue<int,vector<int>,greater<int> >q;
while(n--) {
scanf("%d",&op);
if(op==2) {
printf("%lld\n",ans);
continue;
}
scanf("%d",&x);
if(x>ans) {
q.push(x);
continue;
}
q.push(x);
while(q.size()&&ans>=q.top()) {
ans+=q.top();
q.pop();
}
}
}
return 0;
}
1555: Inversion Sequence
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstdio>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
typedef long long LL;
typedef pair<LL, int> PLI;
const int MX = 2e4 + 5;
const int INF = 0x3f3f3f3f;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define root 1,n,1
#define RR rt<<1|1
#define LL rt<<1
int S[MX << 2], A[MX], B[MX];
void push_up(int rt) {
S[rt] = S[LL] + S[RR];
}
void build(int l, int r, int rt) {
if(l == r) {
S[rt] = 1;
return;
}
int m = (l + r) >> 1;
build(lson);
build(rson);
push_up(rt);
}
int query(int x, int l, int r, int rt) {
if(l == r) {
S[rt] = 0;
return l;
}
int m = (l + r) >> 1, ret;
if(S[LL] >= x) ret = query(x, lson);
else ret = query(x - S[LL], rson);
push_up(rt);
return ret;
}
int main() {
int n;
//freopen("input.txt","r",stdin);
while(~scanf("%d", &n)) {
build(root);
for(int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
bool sign = true;
for(int i = 1; i <= n; i++) {
if(S[1] < A[i] + 1) {
sign = false;
break;
}
B[query(A[i] + 1, root)] = i;
}
if(!sign) printf("No solution\n");
else {
for(int i = 1; i <= n; i++) {
printf("%d%c", B[i], i == n ? '\n' : ' ');
}
}
}
return 0;
}1559: 外卖的撕‘哔’大战
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
struct t
{
int a,b;
}
sale[110];
bool cmp(t x,t y)
{
return x.b>y.b;
}
int price[110];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
scanf("%d%d",&sale[i].a,&sale[i].b);
int before=0; //统计没优惠时的总钱数
for(int i=0;i<m;i++)
{
scanf("%d",&price[i]);
before+=price[i];
}
sort(sale,sale+n,cmp);
sort(price,price+m);
int after=0; //统计能优惠的总金额
for(int i=m-1;i>=0;i--)
{
for(int j=0;j<n;j++)
if(price[i]>=sale[j].a) { after+=sale[j].b; break; }
}
printf("%d\n",before-after);
}
}1560: 图书管理员的表白方式
#include<iostream>
#include<cstring>
using namespace std;
int dp1[105],dp2[105];
int ax[105];
int main()
{
int T;
cin>>T;
while(T--)
{
int N,flag1=0,flag2=0,cnt=100000;
cin>>N;
for(int i=0;i<N;i++)
{
cin>>ax[i];
dp1[i]=dp2[i]=1;
}
for(int j=1;j<N-1;j++)
{
for(int i=0;i<N;i++)
dp1[i]=dp2[i]=1;
int cnt1=0,cnt2=0;
for(int i=j;i>=0;i--)//求左边的最大上升子序列
{
for(int k=i-1;k>=0;k--)
{
if(ax[i]<ax[k])
{
flag1=1;
dp1[k]=max(dp1[k],dp1[i]+1);
}
cnt1=max(dp1[k],cnt1);
}
}
for(int k=j;k<=N-1;k++)//求右边的
{
for(int i=k+1;i<=N-1;i++)
{
if(ax[k]<ax[i])
{
flag2=1;
dp2[i]=max(dp2[i],dp2[k]+1);
}
cnt2=max(dp2[i],cnt2);
}
}
cnt=min(N-(cnt1+cnt2-1),cnt);//求值
}
if(flag1&&flag2)
{
cout<<"HAPPY"<<endl;
cout<<cnt<<endl;
}
else
cout<<"SAD"<<endl;
}
return 0;
}
1561: (More) Multiplication
#include<stdio.h>
const int N =100;
int main()
{
int A,B,C,a[N],b[N],c[N],lenA,lenB,lenC,flag;
while(scanf("%d%d",&A,&B)>0)
{
if(A==0&&B==0)
break;
C=A*B;
lenA=lenB=lenC=0;
while(A)
{
a[++lenA]=A%10; A/=10;
}
while(B)
{
b[++lenB]=B%10; B/=10;
}
while(C)
{
c[++lenC]=C%10; C/=10;
}
for(int i=1,j=lenA;i<j;i++,j--)
{
A=a[i];a[i]=a[j];a[j]=A;
}
flag=lenC;
printf("+-");
for(int i=1;i<=lenA;i++)
printf("----");
printf("--+\n");
printf("| ");
for(int i=1;i<=lenA;i++)
printf(" %d ",a[i]);
printf(" |\n");
for(int i=lenB;i>0;i--)
for(int j=1;j<=4;j++)
{
printf("|");
if(j!=2)
{
if(j!=4||lenC-lenA<i)
printf(" ");
else printf("%d",c[lenC--]);
}
else
{
if(flag-lenA>i)printf("/");
else printf(" ");
}
if(j==1)
{
printf("+");
for(int e=1;e<=lenA;e++)
printf("---+");
printf(" |\n");
}
else if(j==2)
{
for(int e=1;e<=lenA;e++)
printf("|%d /",(a[e]*b[i])/10);
printf("| |\n");
}
else if(j==3)
{
for(int e=1;e<=lenA;e++)
printf("| / ");
printf("|%d|\n",b[i]);
}
else
{
for(int e=1;e<=lenA;e++)
printf("|/ %d",(a[e]*b[i])%10);
printf("| |\n");
}
}
printf("| +");
for(int e=1;e<=lenA;e++)
printf("---+");
printf(" |\n");
printf("|");
if(flag>lenA)
printf("/");
else printf(" ");
while(lenC)
{
printf(" %d ",c[lenC--]);
if(lenC) printf("/");
}
printf(" |\n");
printf("+-");
for(int i=1;i<=lenA;i++)
printf("----");
printf("--+\n");
}
}
1562: Fun House
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
char str[100][100];
int tab[100][100][3];
int main()
{
int n,m,i,j,x,y,h=0,a,b;
while(scanf("%d%d",&n,&m)!=EOF)
{
if(n==0 && m==0)
break;
getchar();
h++;
memset(str,0,sizeof(str));
memset(tab,0,sizeof(tab));
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
cin>>str[j][i];
if(str[j][i]=='*')
{
x=j;
y=i;
}
}
//if(i!=m)
//getchar();
}
if(x==1)
{
tab[x][y][0]=1;
tab[x][y][1]=0;
}
else if(y==1)
{
tab[x][y][0]=0;
tab[x][y][1]=1;
}
else if(y==m)
{
tab[x][y][0]=0;
tab[x][y][1]=-1;
}
else if(x==n)
{
tab[x][y][0]=-1;
tab[x][y][1]=0;
}
while(1)
{
a=tab[x][y][0];
b=tab[x][y][1];
x=x+a;
y=y+b;
tab[x][y][0]=a;
tab[x][y][1]=b;
if(str[x][y]=='x')
{
str[x][y]='&';
break;
}
if(str[x][y]=='.')
continue;
if(str[x][y]=='/')
{
if(tab[x][y][0]==0)
{
if(tab[x][y][1]==1)
{
tab[x][y][0]=-1;
tab[x][y][1]=0;
}
else
{
tab[x][y][0]=1;
tab[x][y][1]=0;
}
}
else if(tab[x][y][1]==0)
{
if(tab[x][y][0]==1)
{
tab[x][y][0]=0;
tab[x][y][1]=-1;
}
else if(tab[x][y][0]==-1)
{
tab[x][y][0]=0;
tab[x][y][1]=1;
}
}
}
if(str[x][y]=='\\')
{
if(tab[x][y][0]==0)
{
if(tab[x][y][1]==1)
{
tab[x][y][0]=1;
tab[x][y][1]=0;
}
else if(tab[x][y][1]==-1)
{
tab[x][y][0]=-1;
tab[x][y][1]=0;
}
}
else if(tab[x][y][1]==0)
{
if(tab[x][y][0]==1)
{
tab[x][y][0]=0;
tab[x][y][1]=1;
}
else
{
tab[x][y][0]=0;
tab[x][y][1]=-1;
}
}
}
}
printf("HOUSE %d\n",h);
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
printf("%c",str[j][i]);
printf("\n");
}
}
}1563: Lexicography
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 100005
char str[50],ans[50];
LL f[50],m;
int main()
{
int i,j,k,len1,len2,cnt[50];
f[0] = 1;
up(i,1,16)
f[i]=f[i-1]*i;
w(~scanf("%s%lld",str,&m))
{
if(str[0]=='#'&&m==0)
break;
mem(cnt,0);
len1 = strlen(str);
sort(str,str+len1);
up(i,0,len1-1)
cnt[str[i]-'A']++;
up(i,0,len1-1)
{
LL last = 0,res;
up(j,0,25)
{
if(cnt[j])
{
res = f[len1-i-1];
up(k,0,25)
{
if(k==j) res/=f[cnt[k]-1];
else res/=f[cnt[k]];
}
if(last+res>=m)
{
ans[i] = j+'A';
m-=last;
cnt[j]--;
break;
}
else
last+=res;
}
}
}
ans[len1]='\0';
puts(ans);
}
return 0;
}1564: The Leprechaun Hunt
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#define prt(k) cout<<#k" = "<<k<<endl;
using namespace std;
typedef long long ll;
const int N = 17;
const int inf = 0x3f3f3f3f;
struct Edge
{
int v, next;
}e[N*N];
int mm, head[N];
void initEdge()
{
mm = 0;
memset(head, -1, sizeof head);
}
void add(int u, int v)
{
e[mm].v = v;
e[mm].next = head[u];
head[u] = mm++;
}
#include <set>
const int MAX = 65580;
int V, n, E;
int to[N];
int go[MAX];
const int LIM = (1<<21) + 77;
int f(int s, int p, int who)
{
return (s << 5) + (p << 1) + who;
}
int getmask(int code)
{
return code >> 5;
}
int getp(int code)
{
code >>= 1;
return code & 15;
}
int getwho(int code ) /// 1 = A
{
return code & 1;
}
/// state, B's position, who's turn
int C(int s) { return __builtin_popcount(s); }
#define INT set<int>::const_iterator
struct State
{
set<int> As;
int B;
bool ATurn;
int code() const
{
int s = 0;
for (INT it = As.begin(); it!=As.end(); it++)
s |= (1<<(*it));
return f(s, B, ATurn ? 1 : 0);
}
State(int code = 0) {
int mask = getmask(code);
B = getp(code);
ATurn = (getwho(code)==1);
for (int i=0;i<n;i++) if (mask >> i & 1)
As.insert(i);
}
vector<State> neighbors() const
{
vector<State> ret;
if (ATurn) {
for (INT it=As.begin(); it != As.end(); it++) {
int u = *it;
for (int i=head[u];~i;i=e[i].next) {
int v = e[i].v;
State t(*this);
t.ATurn = !ATurn;
t.As.erase(u);
if (t.As.count(v)==0) {
t.As.insert(v);
ret.push_back(t);
}
}
}
}
else { /// B turn
State t(*this);
t.ATurn = !ATurn;
if (B != n)
ret.push_back(t);
for (int i=head[B];~i;i=e[i].next) {
int v = e[i].v;
if (t.As.count(v)==0) {
t.B = v;
ret.push_back(t);
}
}
}
return ret;
}
};
void gen(vector<State> &ret, State &u)
{
if (u.As.size() == V) {
ret.push_back(u);
return;
}
int next = u.As.empty() ? 0 : 1 + *(u.As.rbegin());
for (int j=next; j<n; j++) {
u.As.insert(j);
gen(ret, u);
u.As.erase(j);
}
}
#include <map>
int win[LIM];
/// 当前状态为s，动物是不是无论怎么走都会在 p 步（包括它现在走的这一步）内被抓住
bool trapped(const State& s, int p)
{
vector<State> opt = s.neighbors();
for (int j=0;j<opt.size();j++) {
int code = opt[j].code();
if (win[code]==inf || win[code] >= p)
return false;
}
return true;
}
int gao()
{
set<int> now;
vector<State> place;
State model;
model.B = 0;
model.ATurn = false;
gen(place, model);
for (int j=0;j<place.size();j++) {
State s(place[j]);
for (INT it = s.As.begin(); it!=s.As.end();it++) {
s.B = *it;
int code = s.code();
win[code] = 0;
now.insert(code);
}
}
int p = 0;
while (!now.empty()) {
p++;
set<int> news;
for (INT it = now.begin(); it!=now.end(); it++) {
State s(*it);
s.ATurn = !s.ATurn;
if (s.ATurn) {
vector<State> nbr = s.neighbors();
for (int j=0;j<nbr.size();j++) {
nbr[j].ATurn = true;
int code = nbr[j].code();
if (win[code]==inf) {
win[code] = p;
news.insert(code);
}
}
}
else {
State special(s);
special.B = n;
if (trapped(special, p))
return p-1;
vector<State> v = s.neighbors();
for (int i=0;i<v.size();i++) {
v[i].ATurn = false;
int code = v[i].code();
if (win[code]==inf)
if (trapped(v[i], p)) {
win[code] = p;
news.insert(code);
}
}
}
}
now.swap(news);
}
return -1;
}
int main()
{
int ca = 1;
while (cin>>V)
{
if (V==0) break;
cin >> n >> E;
initEdge();
for (int i=0;i<E;i++) {
string s; cin>>s;
int u = s[0]-'A';
int v = s[1]-'A';
add(u, v); add(v, u);
}
for (int i=0;i<n;i++) add(n, i);
memset(win, 63, sizeof win);
int p = gao();
printf("CASE %d: ", ca++);
if (p==-1) puts("NEVER");
else printf("%d\n", (p+1)/2);
}
return 0;
}1565: Word Cloud
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 100005
int w,n;
char str[105][1005];
int s[105],P[105],W[105],len[105],maxn;
int main()
{
int i,j,k,cas = 1,ans;
w(~scanf("%d%d",&w,&n))
{
if(w+n==0)
break;
maxn = 0;
up(i,0,n-1)
{
scanf("%s%d",str[i],&s[i]);
len[i] = strlen(str[i]);
maxn = max(maxn,s[i]);
}
up(i,0,n-1)
{
P[i] = 8+(int)ceil(1.0*40*(s[i]-4)/(maxn-4));
W[i] = (int)ceil(1.0*9*len[i]*P[i]/16);
}
ans = 0;
int flag = 1,maxH=0,now;
up(i,0,n-1)
{
if(flag)
{
ans+=maxH;
maxH=0;
flag=0;
maxH=max(maxH,P[i]);
now=W[i];
}
else
{
if(now+10+W[i]<=w)
{
now+=10+W[i];
maxH=max(maxH,P[i]);
}
else
{
flag=1;
i--;
}
}
}
printf("CLOUD %d: %d\n",cas++,ans+maxH);
}
return 0;
}1566: The Maze Makers
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 100005
int n,m;
int maze[65][65],sx,sy,ex,ey,flag;
char str[1000];
int to[4][3] = {1,0,2,-1,0,8,0,1,4,0,-1,1},vis[65][65];
struct node
{
int x,y;
};
int main()
{
int i,j,k;
while(~scanf("%d%d",&n,&m))
{
if(!n&&!m) break;
mem(vis,0);
up(i,1,n)
{
scanf("%s",str+1);
up(j,1,m)
{
vis[i][j];
if(str[j]>='0'&&str[j]<='9') maze[i][j] = str[j]-'0';
else maze[i][j]=str[j]-'A'+10;
maze[i][j]=~maze[i][j];//按位取反之后，除了不能走的路是0之外，其他位都是1了
}
}
sx = 0;
up(i,1,n)//对于每一行，我们看其左右边界，也就是和1,4相与的结果，为1的话证明这里是入口或者出口
{
if(maze[i][1]&1)
{
if(!sx) sx=i,sy=1;
else ex=i,ey=1;
}
if(maze[i][m]&4)
{
if(!sx) sx=i,sy=m;
else ex=i,ey=m;
}
}
up(i,1,m)//同上，不过这里是对于每一行看上下边界
{
if(maze[1][i]&8)
{
if(!sx) sx=1,sy=i;
else ex=1,ey=i;
}
if(maze[n][i]&2)
{
if(!sx) sx=n,sy=i;
else ex=n,ey=i;
}
}
int mul=0;
queue<node> Q;
node a,next;
a.x = sx;
a.y = sy;
Q.push(a);
vis[sx][sy] = 16;
while(!Q.empty())
{
a = Q.front();
Q.pop();
up(i,0,3)
{
if(vis[a.x][a.y]==to[i][2])continue;//所在点往to[i][2]方向已经访问过了
if(maze[a.x][a.y]&to[i][2])//该方向能够访问
{
next.x = a.x+to[i][0];
next.y = a.y+to[i][1];
if(next.x>=1 && next.x<=n && next.y>=1 && next.y<=m)
{
if(vis[next.x][next.y]) mul=1;
else
{
if(to[i][2]==1) vis[next.x][next.y] = 4;
else if(to[i][2]==4) vis[next.x][next.y] = 1;
else if(to[i][2]==2) vis[next.x][next.y] = 8;
else if(to[i][2]==8) vis[next.x][next.y] = 2;
Q.push(next);
}
}
}
}
}
if(vis[ex][ey])//能走到出口
{
flag = 0;
up(i,1,n)
{
up(j,1,m)
{
if(!vis[i][j])
{
flag = 1;
break;
}
}
if(flag)
break;
}
if(flag)//有一个点没访问到
printf("UNREACHABLE CELL\n");
else
{
if(mul) printf("MULTIPLE PATHS\n");//能出处并且有一个点能被重复访问，则输出多路
else printf("MAZE OK\n");//只有一条路
}
}
else//走不到出口
printf("NO SOLUTION\n");
}
return 0;
}
1567: Reverse Rot
#include<stdio.h>
#include<string.h>
int main()
{
char str[45],mod[]={"ABCDEFGHIJKLMNOPQRSTUVWXYZ_."},ch;
int n;
while(scanf("%d ",&n)>0&&n)
{
//getchar();
scanf("%s",str);
int len=strlen(str);
for(int i=0,j=len-1;i<j;i++,j--)
{
ch=str[i]; str[i]=str[j];str[j]=ch;
}
for(int i=0;i<len;i++)
{
for(int j=0;j<28;j++)
if(str[i]==mod[j])
{
if(j+n<28)
printf("%c",mod[j+n]);
else
printf("%c",mod[j+n-28]);
}
}
printf("\n");
}
}
1569: Wet Tiles
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int map[1005][1005];
int dir[10][2]={{0,0},{1,0},{0,1},{-1,0},{0,-1}};
struct node{
int x,y;
}q[1111111];
int main()
{
int n,m,tt,l,w,i,j,t,a,b,x2,y2,x3,y3,x,y,xx,yy,h;
while(scanf("%d",&n)!=EOF && n!=-1)
{
scanf("%d%d%d%d",&m,&tt,&l,&w);
memset(map,0,sizeof(map));
for(i=1;i<=l;i++){
scanf("%d%d",&a,&b);
q[i].x=a;
q[i].y=b;
map[a][b]=1;
}
for(i=1;i<=w;i++){
scanf("%d%d%d%d",&x2,&y2,&x3,&y3);{
if(x2>x3){
swap(x2,x3);
swap(y2,y3);
}
if(x2==x3){
if(y2>y3){
swap(y2,y3);
}
for(j=y2;j<=y3;j++){
map[x2][j]=-1;
}
}
else if(y2==y3){
for(j=x2;j<=x3;j++){
map[j][y2]=-1;
}
}
else{
if(y2>y3){
for(j=y2;j>=y3;j--){
map[x2][j]=-1;
x2++;
}
}
else {
for(j=y2;j<=y3;j++){
map[x2][j]=-1;
x2++;
}
}
}
}
}
h=1;t=l;
while(h<=t)
{
x=q[h].x;
y=q[h].y;
h++;
if(map[x][y]>=tt)break;
for(i=1;i<=4;i++){
xx=x+dir[i][0];
yy=y+dir[i][1];
if(xx>=1 && xx<=n && yy>=1 && yy<=m && map[xx][yy]==0){
map[xx][yy]=map[x][y]+1;
t++;
q[t].x=xx;
q[t].y=yy;
}
}
}
printf("%d\n",t);
}
return 0;
}1574: Amanda Lounges
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 200005
#define mod 19999997
const int INF = 0x3f3f3f3f;
#define exp 1e-6
typedef pair<int,int> PII;
vector<int> mat[Len];
int n,m,col[Len],flag = 1;
void dfs1(int u,int father,int c)
{
if(!col[u]) col[u]=c;
else if(col[u]==-c)
{
flag = 0;
return;
}
int i,len = mat[u].size();
for(i = 0; i<len; i++)
{
int v = mat[u][i];
if(v == father) continue;
if(col[v] == -c) continue;
dfs1(v,u,-c);
}
}
PII dfs2(int u,int father,int c)
{
PII ret = make_pair(0,0);
if(!col[u]) col[u]=c;
else if(col[u]==-c)
{
flag = 0;
return ret;
}
if(c==1) ret.first++;
else ret.second++;
int len = mat[u].size();
for(int i=0; i<len; i++)
{
int v=mat[u][i];
if(v==father) continue;
if(col[v]==-c) continue;
PII tem=dfs2(v,u,-c);
ret.first+=tem.first;
ret.second+=tem.second;
}
return ret;
}
int main()
{
int i,j,k,a,b,c;
mem(col,0);
scanf("%d%d",&n,&m);
w(m--)
{
scanf("%d%d%d",&a,&b,&c);
c--;
if(c == 0)
{
mat[a].push_back(b);
mat[b].push_back(a);
}
else//确定能染色的，1为染，-1为不染
{
if(col[a]==0) col[a] = c;
else if(col[a]==-c) flag = 0;//染色情况相悖
if(col[b]==0) col[b] = c;
else if(col[b]==-c) flag = 0;
}
}
if(!flag)
{
printf("impossible\n");
return 0;
}
else
{
up(i,1,n)//更新
{
if(col[i])
dfs1(i,i,col[i]);
if(!flag)
{
printf("impossible\n");
return 0;
}
}
int bb=0,ww=0;
up(i,1,n)//计算所有确定的染色情况
{
if(!col[i]) continue;
if(col[i]==1) bb++;
else ww++;
}
int tt = 0;
up(i,1,n)//不确定的，进行搜索
{
if(col[i])continue;
PII tem = dfs2(i,i,1);
tt+=min(tem.first,tem.second);
}
if(!flag)
{
printf("impossible\n");
return 0;
}
printf("%d\n",bb+tt);
}
return 0;
}
1577: Dice Game
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
double sumg,sume;
int ga1,gb1,ga2,gb2,ea1,eb1,ea2,eb2;
int main ()
{
while (scanf("%d%d%d%d",&ga1,&gb1,&ga2,&gb2)!=EOF)
{
sumg = (double)(ga1+gb1)/2+(double)(ga2+gb2)/2;
scanf ("%d%d%d%d",&ea1,&eb1,&ea2,&eb2);
sume = (double)(ea1+eb1)/2+(double)(ea2+eb2)/2;
if (sumg > sume)
printf ("Gunnar\n");
else if (sumg < sume)
printf ("Emma\n");
else
printf ("Tie\n");
}
return 0;
} 1578: Opening Ceremony
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 200005
#define mod 360000
const int INF = 0x3f3f3f3f;
#define exp 1e-6
int a[100005];
int main()
{
int n,i;
w(scanf("%d",&n)!=EOF)
{
up(i,1,n)
scanf("%d",&a[i]);
sort(a+1,a+n+1);
int mmin=n;
up(i,1,n)
{
mmin=min(mmin,(n-i+a[i]));
}
printf("%d\n",mmin);
}
return 0;
}1580: Outing
#include<stdio.h>
#include<vector>
#include<string.h>
using namespace std;
const int N = 1005;
int dfn[N],low[N],Stack[N],flag[N],vist[N],num[N],top,deep,tn;
vector<int>mapt1[N],mapt2[N];
void init(int n)
{
for(int i=1;i<=n;i++)
{
mapt1[i].clear();
mapt2[i].clear();
dfn[i]=0;
num[i]=0;
vist[i]=0;
}
tn=top=deep=0;
}
int tt;
void dfs(int u)
{
deep++; vist[u]=tt;
dfn[u]=low[u]=deep;
Stack[++top]=u;
int len=mapt1[u].size();
for(int i=0;i<len;i++)
{
int v=mapt1[u][i];
if(vist[v]==0)
{
dfs(v);
if(low[u]>low[v])
low[u]=low[v];
}
else if(vist[v]==tt&&low[u]>dfn[v])
low[u]=dfn[v];
}
if(low[u]==dfn[u])
{
tn++;
while(u!=Stack[top])
{
flag[Stack[top]]=tn; num[tn]++;top--;
}
flag[Stack[top]]=tn; num[tn]++; top--;
}
}
int in[N],have[N][N];
void rebuilMap(int n)
{
tt=0;
for(int i=1;i<=n;i++)
if(vist[i]==0)
{
tt++;
dfs(i);
}
memset(in,0,sizeof(in));
memset(have,0,sizeof(have));
for(int i=1;i<=n;i++)
{
int u=flag[i];
for(int j=0;j<mapt1[i].size();j++)
{
int v=flag[mapt1[i][j]];
if(u==v||have[v][u])
continue;
in[u]++; have[v][u]=1;
mapt2[v].push_back(u);
}
}
}
int k;
int solve()
{
int dp[N],a[N],m=0;
memset(dp,0,sizeof(dp));
dp[0]=1;
for(int i=1;i<=tn;i++)
if(in[i]==0&&num[i]<=k)
{
a[m++]=i;
for(int j=k;j>=num[i];j--)
if(dp[j-num[i]]==1)
dp[j]=1;
}
while(m--)
{
int u=a[m];
for(int i=0;i<mapt2[u].size();i++)
{
int v=mapt2[u][i];
in[v]--;
if(in[v]==0&&num[v]<=k)
{
a[m++]=v;
for(int j=k;j>=num[v];j--)
if(dp[j-num[v]]==1)
dp[j]=1;
}
}
}
for(int i=k;i>=0;i--)
if(dp[i])
return i;
return 0;
}
int main()
{
int n;
scanf("%d%d",&n,&k);
{
init(n);
for(int i=1;i<=n;i++)
{
int j;
scanf("%d",&j);
mapt1[i].push_back(j);
}
rebuilMap(n);
printf("%d\n",solve());
}
return 0;
}1581: Clock Pictures
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 200005
#define mod 360000
const int INF = 0x3f3f3f3f;
#define exp 1e-6
int n,a[Len],b[Len],s[Len*2],next1[Len];
void get_next()
{
next1[0] = 0;
int i;
up(i,2,n-1)
{
int t = i-1;
t = next1[t];
w(t!=0 && a[t+1]!=a[i]) t = next1[t];
t++;
if(a[t]==a[i]) next1[i] = t;
else next1[i] = 0;
}
}
int main()
{
int i,j,k;
w(~scanf("%d",&n))
{
up(i,0,n-1)
scanf("%d",&a[i]);
up(i,0,n-1)
scanf("%d",&b[i]);
sort(a,a+n);
sort(b,b+n);
down(i,n-1,1)
a[i]=(a[i]-a[i-1]+mod)%mod;
up(i,0,n-1)
s[i]=s[i+n]=b[i];
down(i,2*n-1,1)
s[i]=(s[i]-s[i-1]+mod)%mod;
int flag = 0;
int pos = 1;
get_next();
up(i,1,2*n-1)
{
if(s[i]!=a[pos])
{
int tem = next1[pos-1];
w(tem && s[i]!=a[tem+1])
tem = next1[tem];
tem++;
if(a[tem]==s[i]) pos = tem+1;
else pos = 1;
}
else pos++;
if(pos == n)
{
flag = 1;
break;
}
}
printf("%s\n",flag?"possible":"impossible");
}
return 0;
}1584: Train Passengers
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
long long C,n;
long long x,y,z;
int flag;
while(scanf("%lld%lld",&C,&n)==2)
{
long long num=0;
flag=1;
for(int i=1;i<=n;i++)
{
scanf("%lld%lld%lld",&x,&y,&z);
if(flag==0)
continue;
if(i<n&&x<=num&&y<C-num+x&&z==0)
{
num=num-x+y;
continue;
}
if(i<n&&x<=num&&y==C-num+x)
{
num=num-x+y;
continue;
}
if(i==n&&x==num&&y==0&&z==0)
{
continue;
}
flag=0;
}
if(flag)
printf("possible\n");
else
printf("impossible\n");
}
return 0;
} 1589: Shaping Regions
#include<cstring>
#include<cstdio>
struct node{
int x1,y1,x2,y2,col;
}p[1005];
int max(int &a,int &b){return a>b?a:b;}
int min(int &a,int &b){return a>b?b:a;}
int n;
int ans[2505];
bool vis[2505];
void pf(int x1,int y1,int x2,int y2,int col,int c) //x1y1为左下的坐标 x2y2为右上的坐标
{
if(x1>=x2||y1>=y2) return; //剪枝1 现在的范围已经不存在了
while(c<=n&&((x2<=p[c].x1)||(y2<=p[c].y1)||(x1>=p[c].x2)||(y1>=p[c].y2)))
c+=1; //剪枝2 如果现在的范围和当前判断的矩形不相交就直接判下一个 不加这个犀利的剪枝大概400ms
if(c>n) {
ans[col]+=(x2-x1)*(y2-y1);
return;
}
if(y1<p[c].y1) pf(max(p[c].x1,x1),y1,max(p[c].x1,x2),min(p[c].y1,y2),col,c+1);
if(y2>p[c].y2) pf(min(x1,p[c].x2),max(y1,p[c].y2),min(p[c].x2,x2),y2,col,c+1);
if(x1<p[c].x1) pf(x1,min(p[c].y2,y1),min(p[c].x1,x2),min(p[c].y2,y2),col,c+1);
if(x2>p[c].x2) pf(max(p[c].x2,x1),max(p[c].y1,y1),x2,max(p[c].y1,y2),col,c+1);
}
int main(){
int T;
scanf("%d",&T);
p[0].x1=p[0].y1=0,p[0].col=1;
while(T--){
scanf("%d%d%d",&p[0].x2,&p[0].y2,&n); //把整个范围看成一个矩形
memset(vis,0,sizeof(vis));
memset(ans,0,sizeof(ans));
for(int i=1;i<=n;++i) {
scanf("%d%d%d%d%d",&p[i].x1,&p[i].y1,&p[i].x2,&p[i].y2,&p[i].col);
vis[p[i].col]=1;
}
vis[1]=1;
for(int i=0;i<=n;++i) pf(p[i].x1,p[i].y1,p[i].x2,p[i].y2,p[i].col,i+1);
for(int i=1;i<=2505;++i)
{
if(vis[i]&&ans[i]) printf("%d %d\n",i,ans[i]);
}
}
}1593: 丹麦海峡
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<queue>
#define ull unsigned long long
#define maxn 60
using namespace std;
bool cmp(pair <int,int> a,pair <int,int> b)
{
if(a.second==b.second)
return a.first<b.first;
return a.second>b.second;
}
int main()
{
int t;
cin >> t;
while(t--)
{
int n,m;
ull value=0;
cin >> n>>m;//n num of firearm m num of enemy
pair <int,int> boat[maxn];
std::vector<int> firearm;
for(int i=0;i<m;i++)
{
int d,v;
cin >> d >> v;
boat[i].first=d;
boat[i].second=v;
}
for (int i = 0; i < n; i++)
{
int f;
cin >> f;
firearm.push_back(f);
}
sort(boat,boat+m,cmp);
sort(firearm.begin(),firearm.end());
int i=0,j=0;
while(i!=m&&firearm.size()!=0)
{
int flag=0;
for (std::vector<int>::iterator k = firearm.begin(); k != firearm.end(); k++)
{
flag=0;
if (*k>=boat[i].first)
{
value+=boat[i].second;
flag=1;
i++;
firearm.erase(k);
break;
}
}
if(flag==0)
i++;
}
cout << value << endl;
}
return 0;
}1596: Dick.Z 的炉石赛
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <iomanip>
#include <algorithm>
#include <memory.h>
#include <iomanip>
using namespace std;
double avewin[9][9]=
{
0.50 , 0.58 , 0.59 ,0.45 , 0.56 , 0.58 , 0.57 , 0.39 , 0.38,
0.42 , 0.50 , 0.65 , 0.75 , 0.68 , 0.52 , 0.40 , 0.55 , 0.60,
0.41 , 0.35 , 0.50 , 0.46 ,0.48 , 0.47 , 0.44 , 0.57 , 0.54,
0.55 , 0.25 , 0.54 , 0.50 , 0.53 , 0.51 , 0.63 , 0.52 , 0.42,
0.44 , 0.32 ,0.52 , 0.47 , 0.50 , 0.47 , 0.46 , 0.55 , 0.46,
0.42 , 0.48 , 0.53 , 0.49 , 0.53 , 0.50 , 0.44 , 0.40 , 0.59,
0.43 , 0.60 ,0.56 , 0.37 ,0.54 , 0.56 , 0.50 , 0.68 , 0.39,
0.61 , 0.45 , 0.43 , 0.48 , 0.45 , 0.60 , 0.32 , 0.50 , 0.48,
0.62 , 0.40 ,0.46, 0.58 , 0.54 , 0.41 , 0.61 , 0.52 , 0.50,
};
string fighter[]={"Druid" ,"Hunter","Mage", "Shaman", "Paladin", "Warlock", "Warrior", "Rogue", "Priest"};
double getWinRate(string f1,string f2)
{
int r,c;
for(int i=0;i<9;i++)
{
if(fighter[i]==f1)
r=i;
if(fighter[i]==f2)
c=i;
}
// cout<<r<<c<<endl;
return avewin[r][c];
}
int main()
{
int t;
int i,j;
double win[3];
double result;
string fighter1[3];
string fighter2[3];
cin>>t;
while(t--)
{
cin>>fighter1[0]>>fighter1[1]>>fighter1[2];
cin>>fighter2[0]>>fighter2[1]>>fighter2[2];
for(i=0;i<3;i++)
{
win[i]=getWinRate(fighter1[i],fighter2[i]);
//cout<<win[i]<<' ';
}
result=1*(win[0]*(1-win[1])*(1-win[2])+(1-win[0])*win[1]*(1-win[2])+(1-win[0])*(1-win[1])*win[2]);
result+=2*(win[0]*win[1]*(1-win[2])+(1-win[0])*win[1]*win[2]+win[0]*(1-win[1])*win[2]);
result+=3*win[0]*win[1]*win[2];
cout<<fixed<<setprecision(2)<<result<<endl;
}
return 0;
}
1597: 薛XX后代的IQ
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
int dp[305][305];
int main()
{
int x,y,a,b,p,n,T;
scanf("%d",&T);
while(T--)
{
scanf("%d %d %d %d %d %d",&x,&y,&a,&b,&p,&n);
memset(dp,0,sizeof(dp));
int id=-1;
for(int i=1; i<=n; i++)
{
if(dp[x][y])
{
id=i;
break;
}
dp[x][y]=i;
int iq=(a*x+b*y)%p;
x=y,y=iq;
}
if(id==-1) printf("%d\n",y);
else
{
int len=id-dp[x][y];
int d=(n-dp[x][y])%len;
if(d==0) d=len;
for(int i=1; i<=d; i++)
{
int iq=(a*x+b*y)%p;
x=y,y=iq;
}
printf("%d\n",(a*x+b*y)%p);
}
}
return 0;
}
2508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
