Codeforces 120I

本文介绍了一种用于生成字典序最小数值的算法,该算法通过对比原字符串与新生成字符串的部分来找到第一个可以使得新串大于原串的位置,并采用贪心策略确保生成的字符串尽可能小。具体步骤包括从后向前枚举新串与原串的第一个较大位置,记录能获得的最大值并递归求解字典序最小值。

从后往前枚举新串与原串第一个大的位置,
然后后面的就可以随便选了,然后我们贪心保存后面能得到的最大值,直到最大值大于原串,
然后递归回去求字典序最小

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int N=2e5+100;
int cc[10]={119,36,93,109,46,107,123,37,127,111};
int mp[10][10];
int num[10],nx;
int f(int x){
    int cnt=0;
    while(x){
        cnt++;x-=x&-x;
    }
    return cnt;
}

int sum[N],sum2[N];char ss[N];
int n,m;
void fun(int id,int x,int ll,int rr){
    ss[id]=x+'0';
    if(id==n){
        printf("%s\n",ss+1);return ;
    }
    ll+=mp[ss[id-m]-'0'][x];rr-=num[ss[id+1-m]-'0'];
    for(int i=0;i<10;i++){
        if(ll+rr+mp[ss[id+1-m]-'0'][i]>sum[m]){
            fun(id+1,i,ll,rr);break;
        }
    }
}
void gun(int id,int x,int ll){
    ss[id]=x+'0';
    if(id==m)return ;
    ll+=num[x];
    for(int i=0;i<10;i++){
        if(ll+num[i]+(m-id-1)*num[nx]>sum[m]){
            gun(id+1,i,ll);break;
        }
    }
}
int main(){
    #ifdef DouBi
    freopen("in.cpp","r",stdin);
    #else
        freopen("input.txt","r",stdin);
        freopen("output.txt","w",stdout);
    #endif // DouBi
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++)mp[i][j]=f(cc[i]&cc[j]);
    }
    nx=0;
    for(int i=0;i<10;i++){
        num[i]=0;
        for(int j=0;j<10;j++){
            num[i]=max(num[i],mp[i][j]);
        }
        if(num[i]>num[nx])nx=i;
    }
    while(scanf("%s",ss+1)!=EOF){
        n=strlen(ss+1);
        m=n/2;
        sum[0]=0;sum2[0]=0;
        for(int i=1;i<=m;i++){
            sum[i]=sum[i-1]+mp[ss[i]-'0'][ss[i+m]-'0'];
            sum2[i]=sum2[i-1]+num[ss[i]-'0'];
        }
        int flag=0,rr=0;
        for(int i=n;i>m;i--){
            for(int j=ss[i]-'0'+1;j<10;j++){
                if(sum[i-m-1]+rr+mp[ss[i-m]-'0'][j]>sum[m]){
                    fun(i,j,sum[i-m-1],rr);flag=1;break;
                }
            }
            if(flag)break;
            rr+=num[ss[i-m]-'0'];
        }
        if(flag)continue;
        for(int i=m;i>=1;i--){
            for(int j=ss[i]-'0'+1;j<10;j++){
                if(sum2[i-1]+(m-i)*num[nx]+num[j]>sum[m]){
                    gun(i,j,sum2[i-1]);
                    flag=1;break;
                }
            }
            if(flag){
                rr=0;
                for(int j=m;j>1;j--){
                    rr+=num[ss[j]-'0'];
                }
                for(int j=0;j<10;j++){
                    if(rr+mp[ss[1]-'0'][j]>sum[m]){
                        fun(m+1,j,0,rr);break;
                    }
                }
                break;
            }
        }
        if(!flag)printf("-1\n");
    }
    return 0;
}
关于 Codeforces Round 1014 Div. 2 的具体题解和比赛详情并未在当前提供的引用中提及。然而,可以基于类似的竞赛结构以及常见的算法问题类型提供一些推测性的分析。 通常情况下,Codeforces 比赛中的题目会涉及多种经典算法领域,例如动态规划、贪心策略、图论、字符串处理等。以下是可能适用于该轮次的一些常见问题类型的解答框架: ### 动态规划 (Dynamic Programming) 如果某道题目涉及到最优子结构性质,则可以通过构建状态转移方程来解决问题。例如,在某些背包类问题中,定义 `dp[i][j]` 表示前 i 件物品容量为 j 时的最大价值[^3]。 ```python def knapsack(values, weights, capacity): n = len(values) dp = [[0]*(capacity+1) for _ in range(n+1)] for i in range(1,n+1): for w in range(capacity+1): if weights[i-1] <= w: dp[i][w] = max(dp[i-1][w], values[i-1]+dp[i-1][w-weights[i-1]]) else: dp[i][w] = dp[i-1][w] return dp[n][capacity] values = [60, 100, 120] weights = [10, 20, 30] capacity = 50 print(knapsack(values, weights, capacity)) ``` ### 贪心算法 (Greedy Algorithm) 当面对资源分配等问题时,采用局部最优策略往往能够达到全局最佳效果。比如安排会议时间表以最大化会议室利用率的情形下,按照结束时间排序并依次选取不冲突的区间即可实现目标[^4]。 ### 图论 (Graph Theory) 对于连通性和最短路徑计算方面的需求,Dijkstra 和 Floyd-Warshall 是两种非常实用的方法。前者适合单源最短路径查询;后者则能解决多源场景下的需求[^5]。 ```python import heapq def dijkstra(graph, start_node): distances = {node: float('inf') for node in graph} distances[start_node] = 0 priority_queue = [(0,start_node)] while priority_queue: current_distance, current_vertex = heapq.heappop(priority_queue) if current_distance > distances[current_vertex]: continue for neighbor, weight in graph[current_vertex].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue,(distance,neighbor)) graph = { 'A': {'B': 1,'C': 4}, 'B': {'A': 1,'C': 2,'D': 6}, 'C': {'A': 4,'B': 2,'D': 3}, 'D': {'B': 6,'C': 3} } dijkstra(graph, 'A') ``` 尽管上述内容并非直接针对 Codeforces Round 1014 Div. 2 提供的具体解决方案,但它涵盖了比赛中可能出现的核心知识点和技术手段。 ####
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值