A签到题排序之后贪心一下就可以了。
const int maxn = 10010;
using namespace std;
struct node
{
int pos;
int num;
}f[maxn];
bool cmp(node a, node b)
{
return a.num < b.num;
}
int p[maxn];
int main()
{
int n, k;
while(cin >>n>>k)
{
for(int i = 0; i < n; i++)
{
cin >>f[i].num;
f[i].pos = i+1;
}
sort(f, f+n, cmp);
int ans = 0;
for(int i = 0; i < n; i++)
{
if(k < f[i].num) break;
p[ans++] = f[i].pos;
k -= f[i].num;
}
cout<<ans<<endl;
for(int i = 0; i < ans; i++) cout<<p[i]<<" ";
cout<<endl;
}
}
B主要是策略每次沿着两个圆心的连线转就可以了，所以次数就是距离dis/2*r，注意处理精度，最后一组的好多人挂在精度上了。
const int maxn = 10010;
using namespace std;
int main()
{
double r, x1, y1, x2, y2;
while(cin >>r>>x1>>y1>>x2>>y2)
{
double dis = sqrt((x1-x2)*(x1-x2)*1.0 + 1.0*(y1-y2)*(y1-y2));
LL xp = dis/(2.0*r);
///cout<<"st == "<<st<<endl;
if(xp*2.0*r < dis) xp++;
cout<<xp<<endl;
}
}
C样例的图解释的很清楚了，按层枚举之后你会发现规律，先判断叶子的位置是在这一层的根节点的哪一边，如果第k层的根节点x是奇数左子树是的根节点是x+1，否则是x+2^(h-k+1)，如果x是偶数那就反过来。
由于我的根节点是从一开始的，不要忘记了判断最后一层就可以了啊。
C. Guess Your Way Out!
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output
Amr bought a new video game "Guess Your Way Out!". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height h.
The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.
Let‘s index all the leaf nodes from the left to the right from 1 to 2h.
The exit is located at some node n where 1?≤?n?≤?2h,
the player doesn‘t know where the exit is so he has to guess his way out!
Amr follows simple algorithm to choose the path. Let‘s consider infinite command string "LRLRLRLRL..." (consisting of alternating characters ‘L‘
and ‘R‘). Amr sequentially executes the characters of the string using following rules:
- Character ‘L‘ means "go to the left child of the current node";
- Character ‘R‘ means "go to the right child of the current node";
- If the destination node is already visited, Amr skips current command, otherwise he moves to the destination node;
- If Amr skipped two consecutive commands, he goes back to the parent of the current node before executing next command;
- If he reached a leaf node that is not the exit, he returns to the parent of the current node;
- If he reaches an exit, the game is finished.
Now Amr wonders, if he follows this algorithm, how many nodes he is going to visit before reaching the exit?
Input
Input consists of two integers h,?n (1?≤?h?≤?50, 1?≤?n?≤?2h).
Output
Output a single integer representing the number of nodes (excluding the exit node) Amr is going to visit before reaching the exit by following this algorithm.
Sample test(s)
input
1 2
output
2
input
2 3
output
5
input
3 6
output
10
input
10 1024
output
2046
Note
A perfect binary tree of height h is a binary tree consisting of h?+?1 levels.
Level 0 consists of a single node called root, level h consists
of2h nodes called leaves.
Each node that is not a leaf has exactly two children, left and right one.
Following picture illustrates the sample test number 3. Nodes are labeled according to the order of visit.
#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <time.h>
#include <map>
#include <set>
#define eps 1e-8
#define M 1000100
#define LL long long
//#define LL long long
#define INF 0x3f3f3f
#define PI 3.1415926535898
#define read() freopen("laser_maze.in", "r", stdin)
#define write() freopen("laser_maze.out", "w", stdout);
const int maxn = 10010;
using namespace std;
int main()
{
LL h, n;
LL p;
while(cin >>h>>n)
{
LL ans = h;
p = 1;
if(h == 1)
{
if(n == 1)
{
cout<<1<<endl;
continue;
}
cout<<2<<endl;
continue;
}
while(1)
{
LL xp = (1LL<<(ans))/2;
if(ans == 1) break;
// cout<<"xp = "<<xp<<endl;
// cout<<"n == "<<n<<endl;
// cout<<"p == "<<p<<endl;
if(n > xp)
{
n -= xp;
if(p%2)
{
LL sp = (1LL<<ans);
p = p+sp;
}
else p++;
}
else
{
if(p%2) p++;
else
{
LL sp = (1LL<<ans);
p = p+sp;
}
}
ans--;
}
if(n>1 && p%2)p++;
if(n == 1 && p%2 == 0) p++;
cout<<p<<endl;
}
}
D，数位dp，当时读题的时候读错了。题意是n位的数字，如果存在他的后缀%k=0，就算一种，求出总数来再mod m 就是结果。dp[i][j][k],代表第i位余数为j时他是否已经存在后缀串整除了，0代表不存在，1代表存在。
D. The Maths Lecture
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output
Amr doesn‘t like Maths as he finds it really boring, so he usually sleeps in Maths lectures. But one day the teacher suspected that Amr is sleeping and asked him a question to make sure he wasn‘t.
First he gave Amr two positive integers n and k.
Then he asked Amr, how many integer numbers x?>?0 exist such that:
- Decimal representation of x (without leading zeroes) consists of exactly n digits;
- There exists some integer y?>?0 such that:
;- decimal representation of y is a suffix of decimal representation of x.
;As the answer to this question may be pretty huge the teacher asked Amr to output only its remainder modulo a number m.
Can you help Amr escape this embarrassing situation?
Input
Input consists of three integers n,?k,?m (1?≤?n?≤?1000, 1?≤?k?≤?100, 1?≤?m?≤?109).
Output
Print the required number modulo m.
Sample test(s)
input
1 2 1000
output
4
input
2 2 1000
output
45
input
5 3 1103
output
590
Note
A suffix of a string S is a non-empty string that can be obtained by removing some number (possibly, zero) of first characters from S.
#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <ctime>
#include <map>
#include <set>
#define eps 1e-9
///#define M 1000100
///#define LL __int64
#define LL long long
///#define INF 0x7ffffff
#define INF 0x3f3f3f3f
#define PI 3.1415926535898
#define zero(x) ((fabs(x)<eps)?0:x)
#define mod 1000000007
#define Read() freopen("autocomplete.in","r",stdin)
#define Write() freopen("autocomplete.out","w",stdout)
#define Cin() ios::sync_with_stdio(false)
using namespace std;
const int maxn = 1010;
LL dp[maxn][110][2];
LL pow_mod(LL a, LL k, LL m)
{
LL b = 1LL;
while(k)
{
if(k&1) b = a*b%m;
a = (a%m)*(a%m)%m;
k >>= 1;
}
return b;
}
int main()
{
LL n, k, m;
while(cin >>n>>k>>m)
{
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for(int i = 1; i <= n; i++)
{
int j = 0;
if(i == n) j++;
for(; j < 10; j++)
{
for(int sk = 0; sk < k; sk++)
{
///LL xp = (sk+j*10LL)%k;
LL xp = (pow_mod(10LL,i-1,k)*j%k+sk)%k;
if(!xp && j) dp[i][xp][1] += dp[i-1][sk][0];
else dp[i][xp][0] += dp[i-1][sk][0];
dp[i][xp][1] %= m;
dp[i][xp][0] %= m;
dp[i][xp][1] += dp[i-1][sk][1];
dp[i][xp][1] %= m;
}
}
}
LL ans = 0;
for(int i = 0; i < k; i++)
{
ans += dp[n][i][1];
ans %= m;
}
cout<<ans<<endl;
}
}
E这题感觉比D题简单，就是有n个城市，m条边。让你求出来1到n的最短路，但是要求，保证最短路的时候，要求权值最大。
E. Breaking Good
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
Breaking Good is a new video game which a lot of gamers want to have. There is a certain level in the game that is really difficult even for experienced gamers.
Walter William, the main character of the game, wants to join a gang called Los Hermanos (The Brothers). The gang controls the whole country which consists of n cities
with m bidirectional roads connecting them. There is no road is connecting a city to itself and for any two cities there is at most one road between them.
The country is connected, in the other words, it is possible to reach any city from any other city using the given roads.
The roads aren‘t all working. There are some roads which need some more work to be performed to be completely functioning.
The gang is going to rob a bank! The bank is located in city 1. As usual, the hardest part is to escape to their headquarters where the police can‘t get them. The
gang‘s headquarters is in city n. To gain the gang‘s trust, Walter is in charge of this operation, so he came up with a smart plan.
First of all the path which they are going to use on their way back from city 1 to their headquarters n must
be as short as possible, since it is important to finish operation as fast as possible.
Then, gang has to blow up all other roads in country that don‘t lay on this path, in order to prevent any police reinforcements. In case of non-working road, they don‘t have to blow up it as it is already malfunctional.
If the chosen path has some roads that doesn‘t work they‘ll have to repair those roads before the operation.
Walter discovered that there was a lot of paths that satisfied the condition of being shortest possible so he decided to choose among them a path that minimizes the total number of affected roads (both roads that have to be blown up and roads to be repaired).
Can you help Walter complete his task and gain the gang‘s trust?
Input
The first line of input contains two integers n,?m (2?≤?n?≤?105, 
),
the number of cities and number of roads respectively.
In following m lines there are descriptions of roads. Each description consists of three integers x,?y,?z (1?≤?x,?y?≤?n, 
)
meaning that there is a road connecting cities number x and y.
If z?=?1, this road is working, otherwise it is not.
Output
In the first line output one integer k, the minimum possible number of roads affected by gang.
In the following k lines output three integers describing roads that should be affected. Each line should contain three integers x,?y,?z (1?≤?x,?y?≤?n, ),
cities connected by a road and the new state of a road. z?=?1 indicates that the road between cities x and yshould
be repaired and z?=?0 means that road should be blown up.
You may output roads in any order. Each affected road should appear exactly once. You may output cities connected by a single road in any order. If you output a road, it‘s original state should be different from z.
After performing all operations accroding to your plan, there should remain working only roads lying on some certain shortest past between city 1 and n.
If there are multiple optimal answers output any.
Sample test(s)
input
2 1 1 2 0
output
1 1 2 1
input
4 4 1 2 1 1 3 0 2 3 1 3 4 1
output
3 1 2 0 1 3 1 2 3 0
input
8 9 1 2 0 8 3 0 2 3 1 1 4 1 8 7 0 1 5 1 4 6 1 5 7 0 6 8 0
output
3 2 3 0 1 5 0 6 8 1
Note
In the first test the only path is 1?-?2
In the second test the only shortest path is 1?-?3?-?4
In the third test there are multiple shortest paths but the optimal is 1?-?4?-?6?-?8
#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <ctime>
#include <map>
#include <set>
#define eps 1e-9
///#define M 1000100
///#define LL __int64
#define LL long long
///#define INF 0x7ffffff
#define INF 0x3f3f3f3f
#define PI 3.1415926535898
#define zero(x) ((fabs(x)<eps)?0:x)
#define mod 1000000007
#define Read() freopen("autocomplete.in","r",stdin)
#define Write() freopen("autocomplete.out","w",stdout)
#define Cin() ios::sync_with_stdio(false)
using namespace std;
const int maxn = 100010;
struct node1
{
int dis;
int dw;
} p[maxn];
struct node
{
int u;
int w;
int next;
} f[maxn*2];
int cnt;
int head[maxn];
int vis[maxn*2];
int pre[maxn];
int xpre[maxn];
struct node2
{
int x, y, z;
}tp[maxn];
void init()
{
cnt = 0;
memset(head, -1, sizeof(head));
memset(pre, -1, sizeof(pre));
memset(vis, 0, sizeof(vis));
memset(xpre, -1, sizeof(xpre));
}
void add(int u, int v, int w)
{
f[cnt].u = v;
f[cnt].w = w;
f[cnt].next = head[u];
head[u] = cnt++;
f[cnt].u = u;
f[cnt].w = w;
f[cnt].next = head[v];
head[v] = cnt++;
}
void bfs(int x, int y)
{
bool flag[maxn];
memset(flag, false, sizeof(flag));
queue<int>que;
int n = y;
for(int i = 1; i <= n; i++)
{
p[i].dis = INF;
p[i].dw = INF;
}
p[x].dis = 0;
p[x].dw = 0;
flag[x] = true;
que.push(x);
while(!que.empty())
{
int sx = que.front();
flag[sx] = false;
que.pop();
for(int i = head[sx]; i != -1; i = f[i].next)
{
int u = f[i].u;
int w = f[i].w;
if(p[u].dis > p[sx].dis+1)
{
p[u].dis = p[sx].dis+1;
pre[u] = sx;
xpre[u] = i;
p[u].dw = p[sx].dw+w;
if(flag[u]) continue;
que.push(u);
flag[u] = true;
}
else if(p[u].dis == p[sx].dis+1 && p[u].dw > p[sx].dw+w)
{
pre[u] = sx;
xpre[u] = i;
p[u].dw = p[sx].dw+w;
if(flag[u]) continue;
que.push(u);
flag[u] = true;
}
}
}
int xp = n;
while(xpre[xp] != -1)
{
vis[xpre[xp]] = 1;
xp = pre[xp];
}
}
int main()
{
int n, m;
while(cin >>n>>m)
{
init();
int x, y, z;
for(int i = 0; i < m; i++)
{
scanf("%d %d %d", &x, &y, &z);
if(z == 0)
{
add(x, y, z+2);
continue;
}
add(x, y, z);
}
bfs(1, n);
int ans = 0;
for(int i = 0; i < cnt; i += 2)
{
int x = f[i].u;
int y = f[i+1].u;
if(x > y) swap(x, y);
int w = f[i].w;
if(vis[i] || vis[i+1])
{
if(w == 2)
{
tp[ans].x = x;
tp[ans].y = y;
tp[ans++].z = 1;
}
}
else
{
if(w == 1)
{
tp[ans].x = x;
tp[ans].y = y;
tp[ans++].z = 0;
}
}
}
cout<<ans<<endl;
for(int i = 0; i < ans; i++)
cout<<tp[i].x<<" "<<tp[i].y<<" "<<tp[i].z<<endl;
}
return 0;
}