湖南省第八届大学生计算机程序设计竞赛（A,B,C,E,F,I,J)
A 三家人
Description
有三户人家共拥有一座花园，每户人家的太太均需帮忙整理花园。A 太太工作了5 天，B 太太则工作了4 天，才将花园整理完毕。C 太太因为正身怀六甲无法加入她们的行列，便出了90元。请问这笔钱如何分给A、B 二位太太较为恰当？A 应得多少元？90/(5+4)*5=$50 元？如果这么想你就上当了！正确答案是60 元。如果没想通的话再想想吧。
下面回答一个一般性的问题：假定A 太太工作了x 天，B 太太工作了y 天，C 太太出了90元，则A 太太应得多少元？输入保证二位太太均应得到非负整数元钱。三个太太工作效率相同。
友情提示：本题有个小小的陷阱哦。如果答案错的话，认真检查一下代码吧。
Input
输入第一行为数据组数T (T<=20)。每组数据仅一行，包含三个整数x, y, z (1<=x, y<=10,1<=z<=1000)。
Output
对于每组数据，输出一个整数，即A 太太应得的金额（单位：元）。
Sample Input
2
5 4 90
8 4 123
Sample Output
60
123
A太太和B太太工作的天数总除以三为每位太太应该工作的天数，减去这个数是帮助C太太工作的天数
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int t;
double w,n,m;
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%lf%lf%lf",&n,&m,&w);
double k=(m+n)/1.0;
double a=n-(k/3.0);
double b=m-(k/3.0);
if(a<=) printf("0\n");
else if(b<=) printf("%.lf\n",w);
else printf("%.lf\n",w*a/(a+b));
}
return ;
}
B 机器人的指令
Description
数轴原点有一个机器人。该机器人将执行一系列指令，你的任务是预测所有指令执行完毕之后它的位置。
·LEFT：往左移动一个单位
·RIGHT: 往右移动一个单位
·SAME AS i: 和第i 条执行相同的动作。输入保证i 是一个正整数，且不超过之前执行指令数
Input
输入第一行为数据组数T (T<=100)。每组数据第一行为整数n (1<=n<=100)，即指令条数。以下每行一条指令。指令按照输入顺序编号为1~n。
Output
对于每组数据，输出机器人的最终位置。每处理完一组数据，机器人应复位到数轴原点。
Sample Input
2
3
LEFT
RIGHT
SAME AS 2
5
LEFT
SAME AS 1
SAME AS 2
SAME AS 1
SAME AS 4
Sample Output
1
-5
水题
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int a[],t,n,k;
char ch[],cch[];
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
int pos=;
for(int i=;i<=n;i++)
{
scanf("%s",ch);
if(ch[]=='L') a[i]=-,pos+=a[i];
else if(ch[]=='R') a[i]=,pos+=a[i];
else scanf("%s%d",cch,&k),a[i]=a[k],pos+=a[i];
}
printf("%d\n",pos);
}
return ;
}
C：Updating a Dictionary
Description
In this problem, a dictionary is collection of key-value pairs, where keys are lower-case letters, and values are non-negative integers. Given an old dictionary and a new dictionary, find out what were changed.
Each dictionary is formatting as follows:
{key:value,key:value,...,key:value}
Each key is a string of lower-case letters, and each value is a non-negative integer without leading zeros or prefix '+'. (i.e. -4, 03 and +77 are illegal). Each key will appear at most once, but keys can appear in any order.
Input
The first line contains the number of test cases T (T<=1000). Each test case contains two lines. The first line contains the old dictionary, and the second line contains the new dictionary. Each line will contain at most 100 characters and will not contain any whitespace characters. Both dictionaries could be empty.
WARNING: there are no restrictions on the lengths of each key and value in the dictionary. That means keys could be really long and values could be really large.
Output
For each test case, print the changes, formatted as follows:
·First, if there are any new keys, print '+' and then the new keys in increasing order (lexicographically), separated by commas.
·Second, if there are any removed keys, print '-' and then the removed keys in increasing order (lexicographically), separated by commas.
·Last, if there are any keys with changed value, print '*' and then these keys in increasing order (lexicographically), separated by commas.
If the two dictionaries are identical, print 'No changes' (without quotes) instead.
Print a blank line after each test case.
Sample Input
3
{a:3,b:4,c:10,f:6}
{a:3,c:5,d:10,ee:4}
{x:1,xyz:123456789123456789123456789}
{xyz:123456789123456789123456789,x:1}
{first:1,second:2,third:3}
{third:3,second:2}
Sample Output
+d,ee
-b,f
*c No changes -first
大模拟，注意输出规则，和键和值都为空时的判断情况
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
char a[];
set<string>s,sadd,smultiply;
set<string>::iterator it;
map<string,string>m;
int t,ok,flag;
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%s",&a);
int len=strlen(a);
string sa,sb;
int la=,lb=;
flag=;
for(int i=;i<len;i++)
{
if(a[i]==':') flag^=;
else if(a[i]==',' || a[i]=='}')
{
if(la || lb) m[sa]=sb,s.insert(sa),sa="",sb="",flag^=;
la=;lb=;
}
else if(flag)
{
if(a[i]!='+') sb+=a[i],lb++;
}
else sa+=a[i],la++;
}
scanf("%s",&a);
len=strlen(a);
flag=;
for(int i=;i<len;i++)
{
if(a[i]==':') flag^=;
else if(a[i]==',' || a[i]=='}')
{
flag^=;
if(la || lb)
{
if(s.count(sa)==) sadd.insert(sa);
else
{
if(m[sa]!=sb) smultiply.insert(sa);
s.erase(sa);
}
}
sa="";sb="";la=;lb=;
}
else if(flag)
{
if(a[i]!='+') sb+=a[i],lb++;
}
else sa+=a[i],la++;
}
if(sadd.size()== && smultiply.size()== && s.size()==) printf("No changes\n\n");
else
{
if(sadd.size()>)
{
ok=;
for(it=sadd.begin();it!=sadd.end();it++)
{
printf("%c",ok==?',':'+');
cout<<*it;ok=;
}
printf("\n");
}
if(s.size()>)
{
ok=;
for(it=s.begin();it!=s.end();it++)
{
printf("%c",ok==?',':'-');
cout<<*it;ok=;
}
printf("\n");
}
if(smultiply.size()>)
{
ok=;
for(it=smultiply.begin();it!=smultiply.end();it++)
{
printf("%c",ok==?',':'*');
cout<<*it;ok=;
}
printf("\n");
}
printf("\n");
}
s.clear();
sadd.clear();
smultiply.clear();
m.clear();
}
return ;
}
/*
4
{X:+123,VYVG:NNNJ}
{X:123,VYVG:NNNJ}
{:123,bgb:456,k:789}
{:124,bgb:123,k:789}
{:123,bgb:456,k:789}
{:123,bgb:452}
{:,xx:xx}
{xx:xx}
*/
/* No changes *,bgb -k
*bgb No changes */
E:最短的名字
Description
在一个奇怪的村子中，很多人的名字都很长，比如aaaaa, bbb and abababab。
名字这么长，叫全名显然起来很不方便。所以村民之间一般只叫名字的前缀。比如叫'aaaaa'的时候可以只叫'aaa'，因为没有第二个人名字的前三个字母是'aaa'。不过你不能叫'a'，因为有两个人的名字都以'a'开头。村里的人都很聪明，他们总是用最短的称呼叫人。输入保证村里不会有一个人的名字是另外一个人名字的前缀（作为推论，任意两个人的名字都不会相同）。
如果村里的某个人要叫所有人的名字（包括他自己），他一共会说多少个字母？
Input
输入第一行为数据组数T (T<=10)。每组数据第一行为一个整数n(1<=n<=1000)，即村里的人数。以下n行每行为一个人的名字（仅有小写字母组成）。输入保证一个村里所有人名字的长度之和不超过1,000,000。
Output
对于每组数据，输出所有人名字的字母总数。
Sample Input
1
3
aaaaa
bbb
abababab
Sample Output
5
简单字典树判断
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
char a[][];
int t,n;
struct trie
{
int cnt;
int len;
struct trie *next[];
trie()
{
cnt=;
len=;
for(int i=;i<;i++)
next[i]=NULL;
}
};
trie *root;
void insert(trie *root,char *s)
{
int len=strlen(s);
trie *p=root,*tmp;
for(int i=;i<len;i++)
{
if(p->next[s[i]-'a']==NULL)
{
tmp=new trie();
p->next[s[i]-'a']=tmp;
}
p=p->next[s[i]-'a'];
p->len=i+;
p->cnt++;
}
}
int find(trie *root,char *s)
{
int len=strlen(s);
trie *p=root;
for(int i=;i<len;i++)
{
if(p->next[s[i]-'a']==NULL) return ;
p=p->next[s[i]-'a'];
if(p->cnt==) return p->len;
}
}
int main()
{
scanf("%d",&t);
while(t--)
{
root=new trie();
scanf("%d",&n);
int ans=;
for(int i=;i<n;i++)
{
scanf("%s",&a[i]);
insert(root,a[i]);
}
for(int i=;i<n;i++)
ans+=find(root,a[i]);
printf("%d\n",ans);
}
return ;
}
F:Kingdoms
Description
A kingdom has n cities numbered 1 to n, and some bidirectional roads connecting cities. The capital is always city 1.
After a war, all the roads of the kingdom are destroyed. The king wants to rebuild some of the roads to connect the cities, but unfortunately, the kingdom is running out of money. The total cost of rebuilding roads should not exceed K.
Given the list of m roads that can be rebuilt (other roads are severely damaged and cannot be rebuilt), the king decided to maximize the total population in the capital and all other cities that are connected (directly or indirectly) with the capital (we call it "accessible population"), can you help him?
Input
The first line of input contains a single integer T (T<=20), the number of test cases.
Each test case begins with three integers n(4<=n<=16), m(1<=m<=100) and K(1<=K<=100,000).
The second line contains n positive integers pi (1<=pi<=10,000), the population of each city.
Each of the following m lines contains three positive integers u, v, c (1<=u,v<=n, 1<=c<=1000), representing a destroyed road connecting city u and v, whose rebuilding cost is c.
Note that two cities can be directly connected by more than one road, but a road cannot directly connect a city and itself.
Output
For each test case, print the maximal accessible population.
Sample Input
2
4 6 6
500 400 300 200
1 2 4
1 3 3
1 4 2
4 3 5
2 4 6
3 2 7
4 6 5
500 400 300 200
1 2 4
1 3 3
1 4 2
4 3 5
2 4 6
3 2 7
Sample Output
1100
1000
要点是必须包含首都即城市1，然后不超过k，人口又尽可能多，刚开始以为是背包，搞不来，一看数据量很小2^15,枚举最小生成树就可以了，这里枚举的是标记路径
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int g[][],n,m,k;
int vis[],dis[];
int pos[],por[],ans,cont;
int x,y,z,t;
void init()
{
for(int i=;i<=n;i++)
{
for(int j=;j<=i;j++)
{
g[i][j]=g[j][i]=(i==j?:INF);
}
}
}
int dij()
{
for(int i=;i<=n;i++)
{
dis[i]=g[][i];
vis[i]=;
}
vis[]=;
int v,maxn,inf=;
for(int i=;i<=n;i++)
{
maxn=INF;
for(int j=;j<=n;j++)
{
if(!vis[j] && pos[j] && maxn>dis[j])
{
maxn=dis[j];
v=j;
}
}
if(maxn==INF) break;
vis[v]=;
inf+=maxn;
for(int j=;j<=n;j++)
{
if(!vis[j] && pos[j]) dis[j]=min(g[v][j],dis[j]);
}
}
for(int i=;i<=n;i++)
{
if(vis[i]!=pos[i]) return INF;
}
return inf;
}
void dfs(int cnt)
{
if(cnt>n)
{
if(dij()<=k)
{
cont=;
for(int i=;i<=n;i++)
{
if(pos[i]) cont+=por[i];
}
ans=max(ans,cont);
}
return ;
}
for(int i=;i<=;i++)
{
pos[cnt]=i;
dfs(cnt+);
}
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&n,&m,&k);
init();
for(int i=;i<=n;i++)
scanf("%d",&por[i]);
for(int i=;i<m;i++)
{
scanf("%d%d%d",&x,&y,&z);
g[x][y]=g[y][x]=min(g[x][y],z);
}
ans=por[];
pos[]=true;
dfs();
printf("%d\n",ans);
}
return ;
}
I:Collecting Coins
Description
In a maze of r rows and c columns, your task is to collect as many coins as possible.
Each square is either your start point "S"(which will become empty after you leave), an empty square ".", a coin square "C" (which will become empty after you step on this square and thus collecting the coin), a rock square "O" or an obstacle square "X".
At each step, you can move one square to the up, down, left or right. You cannot leave the maze or enter an obstacle square, but you can push each rock at most once (i.e. You can treat a rock as an obstacle square after you push it).
To push a rock, you must stand next to it. You can only push the rock along the direction you're facing, into an neighboring empty square (you can't push it outside the maze, and you can't push it to a squarecontiaining a coin).For example, if the rock is to your immediate right, you can only push it to its right neighboring square.
Find the maximal number of coins you can collect.
Input
The first line of input contains a single integer T (T<=25), the number of test cases.
Each test case begins with two integers r and c (2<=r,c<=10), then followed by r lines, each with c columns.
There will be at most 5 rocks and at most 10 coins in each maze.
Output
For each test case, print the maximal number of coins you can collect.
Sample Input
3
3 4
S.OC
..O.
.XCX
4 6
S.X.CC
..XOCC
...O.C
....XC
4 4
.SXC
OO.C
..XX
.CCC
Sample Output
1
6
3
英语差的弱点一下就暴露了，那么多的细节一开始没反应过来，题看了好久才懂什么意思，收集金币，收集过后此地为空，开始坐标走过后为空，中间可能碰到障碍
或者岩石，但岩石可以移动，且每块岩石最多被移动一次，且只能往前进的方向移动，典型的搜索类题型，但有岩石不好搜索，可以先深搜一遍，然后再从岩石处搜索
因为开始的搜索已被标记，不用担心重复，之后两者之和即为解。
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int dir[][]={{,},{,-},{,},{-,}};
int t,n,m,ans,pos,k,cnt,inf;
int vis[][],cont;
char a[][];
struct Node
{
int x;
int y;
int mark;
Node(int a,int b,int c):x(a),y(b),mark(c){}
Node(){}
}node[];
int check(int x,int y)
{
if(x< || x>=n || y< || y>=m) return ;
return ;
}
void dfs(int x,int y,int flag)
{
vis[x][y]=flag;
for(int i=;i<;i++)
{
int nx=x+dir[i][];
int ny=y+dir[i][];
if(!check(nx,ny) || a[nx][ny]=='X' || vis[nx][ny] || a[nx][ny]=='O') continue;
if(a[nx][ny]=='C') cnt++;
dfs(nx,ny,flag);
}
}
void backtrack(int x,int y,int flag)
{
vis[x][y]=;
for(int i=;i<;i++)
{
int nx=x+dir[i][];
int ny=y+dir[i][];
if(!check(nx,ny) || vis[nx][ny]!=flag) continue;
backtrack(nx,ny,flag);
}
}
void solve(int x)
{
if(x>=k || pos+inf==ans) return;
for(int i=;i<k && pos+inf<ans;i++)
{
if(node[i].mark) continue;
node[i].mark=;
for(int j=;j<;j++)
{
int nx=node[i].x+dir[j][],ny=node[i].y+dir[j][];
if(!check(nx,ny) || a[nx][ny]=='X' || !vis[nx][ny]) continue;//是否可以站人
nx=node[i].x-dir[j][],ny=node[i].y-dir[j][];//朝面对的那个方向推
if(!check(nx,ny) || a[nx][ny]!='.') continue;
a[nx][ny]='X',a[node[i].x][node[i].y]='.';
cnt=;
dfs(node[i].x,node[i].y,i+);
cont+=cnt;
int t=cnt;
solve(x+);
inf=max(cont,inf);
backtrack(node[i].x,node[i].y,i+);
cont-=t;
a[nx][ny]='.',a[node[i].x][node[i].y]='O';
}
node[i].mark=;
}
}
int main()
{
scanf("%d",&t);
while(t--)
{
int ax,by;
scanf("%d%d",&n,&m);
k=;ans=;pos=;
for(int i=;i<n;i++)
{
scanf("%s",&a[i]);
for(int j=;j<m;j++)
{
if(a[i][j]=='S') ax=i,by=j,a[i][j]='.';
else if(a[i][j]=='O') node[k++]=Node(i,j,);
else if(a[i][j]=='C') ans++;
}
}
memset(vis,,sizeof(vis));
cnt=;inf=,cont=;
dfs(ax,by,);
pos=cnt;
solve();
pos+=inf;
printf("%d\n",pos);
}
return ;
}
J:病毒
Description
你有一个日志文件，里面记录着各种系统事件的详细信息。自然的，事件的时间戳按照严格递增顺序排列（不会有两个事件在完全相同的时刻发生）。
遗憾的是，你的系统被病毒感染了，日志文件中混入了病毒生成的随机伪事件（但真实事件的相对顺序保持不变）。备份的日志文件也被感染了，但由于病毒采用的随机感染方法，主日志文件和备份日志文件在感染后可能会变得不一样。
给出被感染的主日志和备份日志，求真实事件序列的最长可能长度。
Input
输入第一行为数据组数T (T<=100)。每组数据包含两行，分别描述感染后的主日志和备份日志。
每个日志文件的格式相同，均为一个整数n (1<=n<=1000)（代表感染后的事件总数）和n 个不超过100,000的正整数（表示感染后各事件的时间戳）。
注意，感染后可能会出现时间戳完全相同的事件。
Output
对于每组数据，输出真实事件序列的最长可能长度。
Sample Input
1
9 1 4 2 6 3 8 5 9 1
6 2 7 6 3 5 1
Sample Output
3 刚开始只是简单的以为两次最长子序列然后去最小就可以了，无限wa，最后才发现这样顺序不能保证，所以是最长上升公共子序列，dp一下就可以了
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int a[],b[],dp[];
int n,m,t,ans;
int solve()
{
scanf("%d",&n);
for(int i=;i<n;i++)
scanf("%d",&a[i]);
scanf("%d",&m);
for(int i=;i<m;i++)
scanf("%d",&b[i]);
memset(dp,,sizeof(dp));
for(int i=;i<n;i++)
{
ans=;
for(int j=;j<m;j++)
{
if(a[i]>b[j]) ans=max(ans,dp[j]);
if(a[i]==b[j]) dp[j]=ans+;
}
}
ans=;
for(int i=;i<m;i++)
{
ans=max(ans,dp[i]);
}
return ans;
}
int main()
{
scanf("%d",&t);
while(t--)
{
printf("%d\n",solve());
}
return ;
}
湖南省第八届大学生计算机程序设计竞赛（A,B,C,E,F,I,J)的更多相关文章
- 2016年湖南省第十二届大学生计算机程序设计竞赛---Parenthesis（线段树求区间最值）
原题链接 http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1809 Description Bobo has a balanced parenthes ...
- 2019年湖南省大学生计算机程序设计竞赛 (HNCPC2019) 简要题解
2019年湖南省大学生计算机程序设计竞赛 (HNCPC2019) 简要题解 update10.01 突然发现叉姐把这场的题传到牛客上了,现在大家可以有地方提交了呢. 不知道该干什么所以就来水一篇题解 ...
- 湖南省第十三届大学生计算机程序设计竞赛 Football Training Camp 贪心
2007: Football Training Camp[原创-转载请说明] Submit Page Summary Time Limit: 1 Sec Memory Limit: 1 ...
- 第十一届“蓝狐网络杯”湖南省大学生计算机程序设计竞赛 B - 大还是小? 字符串水题
B - 大还是小? Time Limit:5000MS Memory Limit:65535KB 64bit IO Format: Description 输入两个实数,判断第一个数大 ...
- 2016年湖南省第十二届大学生计算机程序设计竞赛Problem A 2016 找规律归类
Problem A: 2016 Time Limit: 5 Sec Memory Limit: 128 MB Description 给出正整数 n 和 m,统计满足以下条件的正整数对 (a,b) ...
- 湖南省第十二届大学生计算机程序设计竞赛 F 地铁 多源多汇最短路
1808: 地铁 Description Bobo 居住在大城市 ICPCCamp. ICPCCamp 有 n 个地铁站,用 1,2,…,n 编号. m 段双向的地铁线路连接 n 个地铁站,其中第 i ...
- 湖南省第十二届大学生计算机程序设计竞赛 B 有向无环图 拓扑DP
1804: 有向无环图 Time Limit: 5 Sec Memory Limit: 128 MBSubmit: 187 Solved: 80[Submit][Status][Web Board ...
- 湖南省第十二届大学生计算机程序设计竞赛 G Parenthesis
1809: Parenthesis Description Bobo has a balanced parenthesis sequence P=p1 p2…pn of length n and q ...
- 湖南省第十二届大学生计算机程序设计竞赛 A 2016
1803: 2016 Description 给出正整数 n 和 m,统计满足以下条件的正整数对 (a,b) 的数量: 1. 1≤a≤n,1≤b≤m; 2. a×b 是 2016 的倍数. In ...
随机推荐
- 函数响应式编程(FRP)从入门到”放弃”——基础概念篇
前言 研究ReactiveCocoa一段时间了,是时候总结一下学到的一些知识了. 一.函数响应式编程 说道函数响应式编程,就不得不提到函数式编程,它们俩到底有什么关系呢?今天我们就详细的解析一下他们的 ...
- 一：1.1 python程序与数据储存【进制转换】
二进制 :0 1 [逢二进一]0+0=00+1=11+1=1011+1=100 1 1+ 1------ 100 八进制: 0 1 2 3 4 5 6 7 [逢八进一] 1+7=101+2=3 十进制 ...
- caioj 1069 动态规划入门（二维一边推2：顺序对齐）（最长公共子序列拓展总结）
caioj 1068是最长公共子序列裸体,秒过, 就不写博客了 caioj 1069到1071 都是最长公共字序列的拓展,我总结出了一个模型,屡试不爽 (1) 字符串下标从1开始,因为0用来表示 ...
- 【ICM Technex 2018 and Codeforces Round #463 (Div. 1 + Div. 2, combined) B】Recursive Queries
[链接] 我是链接,点我呀:) [题意] 在这里输入题意 [题解] 写个记忆化搜索. 接近O(n)的复杂度吧 [代码] #include <bits/stdc++.h> using nam ...
- ECNUOJ 2856 仰望星空
仰望星空 Time Limit:1000MS Memory Limit:65536KBTotal Submit:373 Accepted:145 Description 我仰望星空, 它是那样辽阔而 ...
- ArcGIS api for javascript—测量，测距问题
首先量测 var map, toolbar, geometryService ; function init() { map=new esri.Map("map",{ extent ...
- Bitmap缓存机制
Bitmap缓存机制 载入一个bitmap到UI里面比較简单直接.可是,假设我们一次载入大量的bitmap数据的时候就变得复杂了.很多情况下(比方这些组件:ListVIew,GridView或者Vie ...
- BZOJ2020: [Usaco2010 Jan]Buying Feed II
[传送门:BZOJ2020] 简要题意: 约翰开车回家,遇到了双十一节,那么就顺路买点饲料吧.回家的路程一共有E 公里,这一路上会经过N 家商店,第i 家店里有Fi 吨饲料,售价为每吨Ci 元.约翰打 ...
- xml Data Type Methods in sql server
nodes() Method (xml Data Type) https://docs.microsoft.com/en-us/sql/t-sql/xml/nodes-method-xml-data- ...
- Task Scheduler
https://technet.microsoft.com/en-us/library/cc748993(v=ws.11).aspx#BKMK_winui If Task Scheduler is n ...