问题 A: 1的个数
[命题人 : admin]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入
输入一个整数（int类型）。
输出
这个数转换成2进制后，输出1的个数。
样例输入 Copy
5
样例输出 Copy
2
n = int(input())
m = bin(n)
t = m[2:]
p = t.count('1')
print(p)问题 B: 又一道简单题
[命题人 : 外部导入]
时间限制 : 5.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
输入一个四个数字组成的整数 n，你的任务是数一数有多少种方法，恰好修改一个数字，把它 变成一个完全平方数（不能把首位修改成 0）。比如 n=7844，有两种方法：3844=622 和 7744=882。
输入
输入第一行为整数 T (1<=T<=1000)，即测试数据的组数，以后每行包含一个整数 n (1000<=n<=9999)。
输出
对于每组数据，输出恰好修改一个数字，把 n变成完全平方数的方案数
样例输入 Copy
2 7844 9121
样例输出 Copy
Case 1: 2 Case 2: 0
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
int a[105];
int main()
{
for (int i = 32; i < 100; i++)
{
a[i] = i * i;
}
int T;
cin >> T;
for (int k = 1; k <= T; k++)
{
int n;
int num = 0;
int cnt = 0;
cin >> n;
num = cnt = 0;
for (int i = 32; i < 100; i++)
{
int x = a[i];
int y = n;
for (int j = 0; j < 4; j++)
{
int w = x % 10;
int z = y % 10;
if (w != z)cnt++;
x /= 10;
y /= 10;
}
if (cnt == 1)
num++;
cnt = 0;
}
cout << "Case " << k << ": " << num << endl;
}
return 0;
}问题 C: 安置路灯
[命题人 : admin]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
小Q正在给一条长度为n的道路设计路灯安置方案。
为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。
小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。
小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。
输入
输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数 接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。 第二行一个字符串s表示道路的构造,只包含'.'和'X'。
输出
对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。
样例输入 Copy
2 3 .X. 11 ...XX....XX
样例输出 Copy
1 3
t = int(input())
for p in range(t):
n = int(input())
road = input()
count = 0
i = 0
while i < n:
if road[i] == '.':
count += 1
i += 3
else:
i += 1
print(count)问题 D: 单源最短路径问题
[命题人 : 201501010119]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
编程实现Dijkstra算法，求一个有向加权图中，从源点出发到其他各个顶点的最短路径。
输入
第1行第1个值表示顶点个数，第2个值表示边个数；第2行开始为边（两个顶点，边的起点和终点）及权重。
输出
顶点0到每一个顶点的最短路径长度。
样例输入 Copy
5 7 0 1 10 0 3 30 0 4 100 1 2 50 2 4 10 3 2 20 3 4 60
样例输出 Copy
0 10 50 30 60
def Dijkstra(G, start):
start -= 1
nod = len(G)
vis = [0] * nod
dis = {node: G[start][node] for node in range(nod)}
vis[start] = 1
last = start
for i in range(nod - 1):
min_dis = inf
for j in range(nod):
if vis[j] == 0 and dis[j] < min_dis:
min_dis = dis[j]
last = j
vis[last] = 1
for k in range(nod):
if G[last][k] < inf and dis[k] > dis[last] + G[last][k]:
dis[k] = dis[last] + G[last][k]
return dis.values()
inf = float('inf')
n, m = map(int, input().split())
G = [[inf] * n for _ in range(n)]
for i in range(n):
G[i][i] = 0
for i in range(m):
a, b, d = map(int, input().split())
G[a][b] = d
print(*Dijkstra(G, 1))问题 E: ABC + DEF = GHI
[命题人 : 201501010119]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
用1, 2, 3...9 这九个数字组成一个数学公式，满足：ABC + DEF = GHI，每个数字只能出现一次，编写程序输出所有的组合。
输入
无
输出
输出所有的 ABC + DEF = GHI，
每行一条数据，格式为ABC+DEF=GHI
输出结果按照ABC升序排列，如果ABC相同，则按照DEF升序排列。
import itertools
def find_combinations():
combinations = []
for perm in itertools.permutations(range(1, 10)):
a = perm[0]
b = perm[1]
c = perm[2]
d = perm[3]
e = perm[4]
f = perm[5]
g = perm[6]
h = perm[7]
i = perm[8]
x1 = a * 100 + b * 10 + c
x2 = d * 100 + e * 10 + f
x3 = g * 100 + h * 10 + i
if x1 + x2 == x3:
combinations.append((x1, x2, x3))
combinations.sort(key=lambda x: (x[0], x[1]))
for combination in combinations:
print(f"{combination[0]}+{combination[1]}={combination[2]}")
find_combinations()题目描述
输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻（横、竖或者对角线方向），即属于同一个八连块。
输入
输入行数m，以及列数n。
然后输入*和@
1<=n,m<=100
输出
样例输入 Copy
<span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">5 5
****@
*@@*@
*@**@
@@@*@
@@**@</span></span></span></span></span>样例输出 Copy
<span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">2</span></span></span></span></span>import sys
sys.setrecursionlimit(int(1e6))
while True:
m, n = map(int, input().split())
str = [list(input()) for _ in range(m)]
vst = [[False] * n for _ in range(m)]
dir = [[-1, -1], [-1, 0], [-1, 1],
[0, -1], [0, 1],
[1, -1], [1, 0], [1, 1]]
def check(x, y):
if not vst[x][y] and 0 <= x < m and 0 <= y < n and str[x][y] == '@':
return True
else:
return False
def dfs(x, y):
vst[x][y] = True
for i in range(8):
nx, ny = x + dir[i][0], y + dir[i][1]
if 0 <= nx < m and 0 <= ny < n and check(nx, ny):
dfs(nx, ny)
count = 0
for i in range(m):
for j in range(n):
if not vst[i][j] and str[i][j] == '@':
dfs(i, j)
count += 1
print(count)问题 G: 迷宫问题（回溯法求解）
[命题人 : 201701080148]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
输入一个n×n的迷宫，定义左上角为起点，右下角为终点，寻找一条从起点到终点的路径
输入
多组输入
每组输入第一行有两个整数n，m表示迷宫尺寸
后跟n行，每行m个字符0表示道路，1表示墙壁
1<=n,m<=10
输出
输出地图，用2表示路径
多个答案输出任意一种即可
样例输入 Copy
5 5 0 1 1 1 1 0 0 0 0 1 1 1 1 0 1 0 0 0 0 1 0 1 1 0 0
样例输出 Copy
2 1 1 1 1 2 2 2 2 1 1 1 1 2 1 0 0 0 2 1 0 1 1 2 2
deals = [lambda x, y: (x + 1, y), # 向下
lambda x, y: (x, y + 1), # 向右
lambda x, y: (x - 1, y), # 向上
lambda x, y: (x, y - 1), # 向左
]
def deal_maze(start, end, maze):
global ans
flag = False
path = []
path.append(start)
maze[0][0] = 2
while len(path) > 0:
curnode = path[-1]
if curnode[0] == end[0] and curnode[1] == end[1]:
flag = True
for i in path:
ans.append(i)
return True
for deal in deals:
nextnode = deal(curnode[0], curnode[1])
if 0 <= nextnode[0] <= end[0] and 0 <= nextnode[1] <= end[1]:
if maze[nextnode[0]][nextnode[1]] == 0:
path.append(nextnode)
maze[nextnode[0]][nextnode[1]] = 2
break
else:
path.pop()
else:
return False
while True:
ans = []
[a, b] = list(map(int, input().split()))
maze = []
for i in range(a):
maze.append([int(j) for j in input().split()])
deal_maze((0, 0), (a - 1, b - 1), maze)
for i in range(len(ans)):
maze[ans[i][0]][ans[i][1]] = 2
for i in range(a):
print(*maze[i])问题 H: 低碳出行
[命题人 : admin]
时间限制 : 1.000 sec 内存限制 : 128 MB
提交问题列表
题目描述
为了做一项关于“爱护环境，从小做起”的公益调查，新司机小明决定开老爸的车从家中前往X市第一小学。从小明家到X市第一小学的交通网络图一共有n个顶点（包括起点小明家和终点X市第一小学）和m条无向边。每条边都有一个碳排放量和一个行驶时间（单位：分钟）。
现在需要你编写一个程序帮助小明实现低碳出行，即寻找一条碳排放量最少的路径，一条路径的碳排放量等于该路径上所有边的碳排放量之和。如果存在两条碳排放量相同的路径，则找出总的行驶时间最少的路径，并输出该路径的总碳排放量和总的时间（分钟）。
输入
单组输入。
在每组输入中，第1行包含两个正整数n和m，分别表示顶点数和边数（n<=1000且m<=1000）。其中，第1号顶点为起点（小明家），第n号顶点为终点（X市第一小学）。两个正整数之间用空格隔开。
第2行到第m+1行表示m条边的信息，每一行包含四个正整数。第1个正整数和第2个正整数表示一条边所对应的两个顶点的编号，第3个正整数表示该边对应的碳排放量，第4个正整数表示该边所对应的行驶时间（单位：分钟）。四个正整数两两之间用空格隔开。
输出
对于每组输入，输出碳排放量最少的路径的总碳排放量和总时间（分钟），如果存在两条碳排放量相同的路径，则输出总的行驶时间最少的路径的总碳排放量和总时间。
样例输入 Copy
3 3 1 2 5 5 1 3 8 11 2 3 3 5
样例输出 Copy
8 10
import math
while True:
n, m = map(int, input().split())
maze = [[math.inf] * n for _ in range(n)]
for i in range(n):
maze[i][i] = 0
exp = [[0] * n for _ in range(n)]
for i in range(m):
x, y, e, d = map(int, input().split())
maze[x - 1][y - 1] = d
maze[y - 1][x - 1] = d
exp[x - 1][y - 1] = e
exp[y - 1][x - 1] = e
for i in range(n):
for j in range(n):
for k in range(n):
if maze[i][j] > maze[i][k] + maze[k][j]:
exp[i][j] = exp[i][k] + exp[k][j]
maze[i][j] = maze[i][k] + maze[k][j]
print(exp[0][-1], maze[0][-1])import math
while True:
n, m = map(int, input().split())
cc, tim = [[math.inf] * (n + 1) for _ in range(n + 1)], [[math.inf] * (n + 1) for _ in range(n + 1)]
for _ in range(m):
a, b, c, d = map(int, input().split())
cc[a][b] = cc[b][a] = min(c, cc[a][b])
tim[a][b] = tim[b][a] = min(d, tim[a][b])
s, t = 1, n
vis, co, ti = [0] * (n + 1), [0] * (n + 1), [0] * (n + 1)
for i in range(1, n + 1):
co[i], ti[i] = cc[s][i], tim[s][i]
co[s], ti[s], vis[s] = 0, 0, 1
for i in range(n - 1):
ind, min_cc, min_time = 0, math.inf, math.inf
for j in range(1, n + 1):
if not vis[j] and (co[j] < min_cc or (co[j] == min_cc and ti[j] < min_time)):
min_cc, min_time, ind = co[j], ti[j], j
vis[ind] = 1
for v in range(1, n + 1):
tmp_cc, tmp_time = co[ind] + cc[ind][v], ti[ind] + tim[ind][v]
if not vis[v] and (tmp_cc < co[v] or (tmp_cc == co[v] and tmp_time < ti[v])):
co[v], ti[v] = tmp_cc, tmp_time
print(co[t], ti[t])
912
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
