世界杯积分问题

DEBUG = False

ans = set()

def dfs(i, j, score, cur_result):
    # 0: i胜利, 1: j胜利, 2:平局
    if cur_result == 0:
        score[i] += 3
    elif cur_result == 1:
        score[j] += 3
    else:
        score[i] += 1
        score[j] += 1

    if i == 4 and j == 5: # 当所有比赛都完成时
        ans.add(tuple(sorted(score[1:], reverse=True)))
        return

    nxt_i = i
    nxt_j = j + 1
    if nxt_j > 5: # 如果下一队的编号超过了队伍总数，则增加当前队的编号
        nxt_i += 1
        nxt_j = nxt_i + 1

    # 继续递归
    for result in range(3):
        dfs(nxt_i, nxt_j, list(score), result)

# 从第1队开始，进行递归调用
for result in range(3):
    dfs(1, 2, [0] * 6, result)

full_cnt = len(ans)
if DEBUG:
    print(full_cnt)

quest_cnt = int(input())
quest_comb = tuple(sorted(map(int, input().split()), reverse=True))
print(f"{'yes' if full_cnt == quest_cnt else 'no'} {'yes' if quest_comb in ans else 'no'}")

from copy import deepcopy
 
scores = []
#枚举10轮比赛，0vs1, 0vs2, 0vs3, 0vs4, 1vs2, 1vs3, 1vs4, 2vs3, ...3vs4
def enum(epoch, score):
    if epoch == 10:
        scores.append(score)
        return
    for i in [1, 0, 3]:
        score.append(i)
        enum(epoch+1, deepcopy(score))
        score = score[:-1]
enum(0, [])
#对于每中可能得10场比赛分别计算每个队伍获得的分数，并排序
scores = [
    sorted([ 
        sum(score[:4]),
        sum([score[i] if score[i] == 1 else 3 - score[i] for i in [0]] + score[4:7]),
        sum([score[i] if score[i] == 1 else 3 - score[i] for i in [1, 4]] + score[7:9]),
        sum([score[i] if score[i] == 1 else 3 - score[i] for i in [2, 5, 7]] + score[9:10]),
        sum([score[i] if score[i] == 1 else 3 - score[i] for i in [3, 6, 8, 9]]),
    ], reverse=True)
    for score in scores
]
#转为字符，去重
scores = [list(map(str, score)) for score in scores]
scores = set([" ".join(score) for score in scores])
total = len(scores)   
 
if __name__ == "__main__":
    N = input()
    score = input()
    print("yes" if int(N) == total else "no", "yes" if score in scores else "no")

import sys

# 设置递归深度限制，以防在穷举时栈溢出
sys.setrecursionlimit(2000)

n = 5  # 5支球队
m = 10  # 总场数
win, fail, even = 3, 0, 1  # 比赛得分规则

# 所有可能的得分组合集合
all_possible_scores = set()

# 定义球队对，总共10场比赛
# 单循环 1-(2,3,4,5), 2-(3,4,5), 3-(4, 5), 4-(5)
teams = list(range(n))
matches = []
for i in range(n):
    for j in range(i + 1, n):
        matches.append((i, j))


def generate_scores(match_idx, current_scores):
    """
    递归函数，穷举所有比赛结果并计算得分。
    
    Args:
        match_idx (int): 当前正在处理的比赛索引。
        current_scores (list): 一个列表，存储每支球队当前的得分。
    """
    # 递归终止条件：所有比赛都已处理
    if match_idx == m:
        # 对得分进行排序并转换为元组，然后存入集合中去重
        sorted_scores = tuple(sorted(current_scores, reverse=True))
        all_possible_scores.add(sorted_scores)
        return

    A, B = matches[match_idx]

    # 情况1: A 胜 B 负
    scores = list(current_scores)
    scores[A] += win
    scores[B] += fail
    generate_scores(match_idx + 1, scores)

    # 情况2: A 负 B 胜
    scores = list(current_scores)
    scores[A] += fail
    scores[B] += win
    generate_scores(match_idx + 1, scores)

    # 情况3: 平局
    scores = list(current_scores)
    scores[A] += even
    scores[B] += even
    generate_scores(match_idx + 1, scores)


def main():
    check_num = int(sys.stdin.readline())
    check_scores = tuple(map(int, sys.stdin.readline().split()))

    # 生成所有可能的得分组合
    initial_scores = [0] * n
    generate_scores(0, initial_scores)

    # 1. 输入的数值是否等于所有组合的数目
    total_count = len(all_possible_scores)
    is_count_correct = "yes" if check_num == total_count else "no"

    # 2.输入的降序得分组合是否在集合中
    is_score_possible = "yes" if check_scores in all_possible_scores else "no"

    # 输出
    print(f"{is_count_correct} {is_score_possible}")


if __name__ == "__main__":
    main()

//直接dfs10场比赛即可
#include <algorithm>
#include <cstring>
#include <iostream>
#include <set>
#include <vector>
using namespace std;

const int TEAM_N = 5;

int race[20];

set<vector<int>> p;

void rank_race() {
    int race_cnt = 1;
    vector<int> team_rank(5, 0);

    for(int i = 0; i < TEAM_N; i++) {
        for(int j = 0; j < i; j++) {
            if(race[race_cnt] == 1) {
                team_rank[i] += 3;
            }
            else if(race[race_cnt] == 0) {
                team_rank[i] += 1;
                team_rank[j] += 1;
            }
            else {
                team_rank[j] += 3;
            }

            race_cnt++;
        }
    }

    sort(team_rank.rbegin(), team_rank.rend());

    // for(int i = 1; i <= TEAM_N; i++) {
    //     cout<<team_rank[i];
    // }
    
    p.insert(team_rank);
}

void dfs(int cur) {
    if(cur == 11) {
        rank_race();
        return;
    }
    race[cur] = 1;
    dfs(cur + 1);
    race[cur] = 0;
    dfs(cur + 1);
    race[cur] = -1;
    dfs(cur + 1);
}
int main() {
    dfs(1);

    int ans = p.size();
    int ans_mb;

    cin>>ans_mb;
    if(ans_mb != ans) cout<<"no";
    else cout<<"yes";

    cout<<" ";
    vector<int> p_t;
    for(int i = 1; i <= TEAM_N; i++) {
        int a;

        cin>>a;
        p_t.push_back(a);
    }

    if(p.find(p_t) != p.end()) cout<<"yes";
    else cout<<"no";

    return 0;
}
// 64 位输出请用 printf("%lld")

#include <functional>
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
 
typedef pair<int, int> PII;
 
vector<PII> coms {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 4}, {2, 5}, {3, 4}, {3, 5}, {4, 5}};
 
set<vector<int>> s;
 
vector<int> temp (5, 0);
 
void dfs(int i) {
    if (i == 10) {
         
        vector<int> backup = temp;
        sort(backup.begin(), backup.end(), greater<> ());
 
        s.insert(backup);
 
        return ;
    }
 
    auto& [a, b] = coms[i];
 
    // a win
    temp[a - 1] += 3;
    dfs(i + 1);
 
 
    // b win
    temp[a - 1] -= 3;
    temp[b - 1] += 3;
    dfs(i + 1);   
 
    // a-b
    temp[a - 1] += 1;
    temp[b - 1] -= 2;
    dfs(i + 1);
 
    temp[a - 1] -= 1;
    temp[b - 1] -= 1;
     
}
 
 
int main() {
    dfs(0);
    int query = 0;
    cin >> query;
 
    if (query == s.size()) cout << "yes ";
    else cout << "no ";
 
    vector<int> query_arr (5, 0);
    for (int i = 0; i < 5; i ++) {
        cin >> query_arr[i];
    }
 
    if (s.count(query_arr)) cout << "yes ";
    else cout << "no ";
 
    return 0;
 
     
}