Codeforces Round #287 (Div. 2) A、B、C、D、E

A：签到题，排序判断一下能学几门即可

B：圆心可以每步可以移动2 * r的距离，方向任选，所以答案是ceil(两点距离 / 2 / r)

C：递归下去就可以了，dfs(h, n, flag)，h表示当前到哪层，n表示当前层下的出口相对位置，flag表示下一步往左还是往右

D：数位DP，从最低位往最高位去放数字，如果一旦出现取模为0，就可以直接计算种数位后面还剩多少位，最后一位可以放1-9，其他都是0-9，不然就继续记忆化搜下去

E：最短路，把图建起来，假设1边总数为x，选择的路径上1边数位a，0边数为b，那么答案就是x - a + b条，答案要尽量小，所以最短路选1的优先级要大于选0的优先级，这个处理方式可以直接把边权扩大10W倍，然后0边多+1即可

代码：

A：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 105;

int n, k;

struct SB {
int a, id;
} sb
;

bool cmp(SB a, SB b) {
return a.a < b.a;
}

int main() {

scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &sb[i].a);
sb[i].id = i;
}
sort(sb, sb + n, cmp);
int tot = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (tot + sb[i].a > k) break;
tot += sb[i].a;
cnt++;
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++)
printf("%d ", sb[i].id + 1);
return 0;
}

B：
#include <cstdio>
#include <cstring>
#include <cmath>

double r, xa, ya, xb, yb;
const double eps = 1e-8;

int main() {
scanf("%lf%lf%lf%lf%lf", &r, &xa, &ya, &xb, &yb);
double d = sqrt((xb - xa) * (xb - xa) + (yb - ya) * (yb - ya));
printf("%.0lf\n", ceil(d / r / 2));
return 0;
}

C：
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;

int h;
ll n;

ll dfs(int d, ll n, int lr) {
if (d == h) return 0;
if (!lr && n > (1LL<<(h - d - 1)))
return (1LL<<(h - d)) + dfs(d + 1, n - (1LL<<(h - d - 1)), 0);
if (lr && n <= (1LL<<(h - d - 1)))
return (1LL<<(h - d)) + dfs(d + 1, n, 1);
if (!lr && n <= (1LL<<(h - d - 1)))
return dfs(d + 1, n, 1) + 1;
if (lr && n > (1LL<<(h - d - 1)))
return dfs(d + 1, n - (1LL<<(h - d - 1)), 0) + 1;
}

int main() {
scanf("%d%lld", &h, &n);
printf("%lld\n", dfs(0, n, 0));
return 0;
}

D:
#include <cstdio>
#include <cstring>

typedef long long ll;
const int N = 1005;
const int M = 105;

int n, k;
ll m, pow10
;
ll dp
[M][2];

ll pow_mod(ll x, int k) {
ll ans = 1;
while (k) {
if (k&1) ans = ans * x % m;
x = x * x % m;
k >>= 1;
}
return ans;
}

ll dfs(int u, int mod, int flag) {
ll &ans = dp[u][mod][flag];
if (ans != -1) return ans;
ans = 0;
if (u == n) return ans;
int s = 0;
if (u == n - 1) s = 1;
for (int i = s; i <= 9; i++) {
int next = (pow10[u] * i + mod) % k;
int f = flag;
if (i > 0) f = 1;
if (next == 0 && f) {
if (n - u - 2 >= 0)
ans = (ans + pow_mod(10LL, n - u - 2) * 9 % m) % m;
else ans = (ans + 1) % m;
}
else {
ans = (ans + dfs(u + 1, next, f)) % m;
}
}
return ans;
}

int main() {
scanf("%d%d%lld", &n, &k, &m);
pow10[0] = 1;
for (int i = 1; i < N; i++)
pow10[i] = pow10[i - 1] * 10 % k;
memset(dp, -1, sizeof(dp));
printf("%lld\n", dfs(0, 0, 0));
return 0;
}

E:
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

#define INF 0x3f3f3f3f3f3f3f

typedef long long ll;
const int MAXNODE = 100005;
const int N = 100005;

struct Edge {
int u, v, use;
ll dist;
Edge() {}
Edge(int u, int v, ll dist) {
this->u = u;
this->v = v;
this->dist = dist;
this->use = 0;
}
};

Edge out
;
int on;

struct HeapNode {
ll d;
int u;
HeapNode() {}
HeapNode(ll d, int u) {
this->d = d;
this->u = u;
}
bool operator < (const HeapNode& c) const {
return d > c.d;
}
};

struct Dijkstra {
int n, m;
vector<Edge> edges;
vector<int> g[MAXNODE];
bool done[MAXNODE];
ll d[MAXNODE];
int p[MAXNODE];

void init(int tot) {
n = tot;
for (int i = 1; i <= n; i++)
g[i].clear();
edges.clear();
}

void add_Edge(int u, int v, ll dist) {
edges.push_back(Edge(u, v, dist));
m = edges.size();
g[u].push_back(m - 1);
}

void dijkstra(int s) {
priority_queue<HeapNode> Q;
for (int i = 1; i <= n; i++) d[i] = INF;
d[s] = 0;
p[s] = -1;
memset(done, false, sizeof(done));
Q.push(HeapNode(0, s));
while (!Q.empty()) {
HeapNode x = Q.top(); Q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < g[u].size(); i++) {
Edge& e = edges[g[u][i]];
if (d[e.v] > d[u] + e.dist) {
d[e.v] = d[u] + e.dist;
p[e.v] = g[u][i];
Q.push(HeapNode(d[e.v], e.v));
}
}
}
}

void print() {
int u = n;
on = 0;
while (p[u] != -1) {
edges[p[u]].use = 1;
edges[p[u]^1].use = 1;
u = edges[p[u]].u;
}
for (int i = 0; i < edges.size(); i += 2) {
if (edges[i].use == 0 && edges[i].dist == 100000) {
out[on] = edges[i];
out[on].dist = 0;
on++;
} else if (edges[i].use == 1 && edges[i].dist == 100001) {
out[on] = edges[i];
out[on].dist = 1;
on++;
}
}
printf("%d\n", on);
for (int i = 0; i < on; i++) {
int a = out[i].u;
int b = out[i].v;
ll c = out[i].dist;
printf("%d %d %lld\n", a, b, c);
}
}
} gao;

int n, m;

int main() {
scanf("%d%d", &n, &m);
gao.init(n);
int u, v, w;
while (m--) {
scanf("%d%d%d", &u, &v, &w);
if (w == 1) {
gao.add_Edge(u, v, 100000);
gao.add_Edge(v, u, 100000);
} else {
gao.add_Edge(u, v, 100001);
gao.add_Edge(v, u, 100001);
}
}
gao.dijkstra(1);
gao.print();
return 0;
}