Codeforces Round #257 (Div. 2) | 前4题

最新推荐文章于 2023-04-03 03:37:20 发布

AC_vitasoy

最新推荐文章于 2023-04-03 03:37:20 发布

阅读量422

点赞数

分类专栏： OJ——Codeforces 文章标签： Codeforces Round #257 Div. 2

本文链接：https://blog.csdn.net/u011580493/article/details/38015297

版权

OJ——Codeforces 专栏收录该内容

49 篇文章 0 订阅

订阅专栏

*其实本该昨天就写记录的，拖到今天也是迫不得已。

A：当时整个人傻乎乎的。。

题意：

小孩子排队要糖果，每排一次队将得到m块糖果。如果该小朋友得到足够的糖果，则立刻回家，否则会回到队列最后。问你最后一个回家的的小朋友的序号（序号是一开始队列的下标，start from 1）；

思路：

求出每个小孩所要排队的次数，取最大值。如果有多个最大值，以最右边的最大值为准。

————————————————————————————————————————————————————————————————————

B：这题把我坑的。。。我还以为-1%100的结果就是-1，想了半天。数学不行啊orz，也奇怪为何电脑程式里面这样设计。

题意：

给你f1 = x， f2 = y，f(i) = f(i+1) + f(i-1)，输入一个i，让你求出f(i)的值是多少。

思路：

先在纸上写出前几个f(i)的值，然后开始找规律。这个是根据除数还有余数来的，余数是用来确定是f1,f2还是f3，除数是用来确定正负的。不过对于3的倍数，

即f6，f9的正负判断与其他的刚好是相反的。注意点就好。我也不废话了，最好自己模拟一下。

C：后来做的，铭神又叫我感受一下了！

题意：一个n*m的矩阵，让你切k刀，尽量让最小的那块的值最大（也就是说，切k刀有很多种方法，因此最小的那块的大小也不一定相同。）

思路：

先看看这个式子 n/(k+1)，表示在n行里，横着切k刀，最小块所占的行数。

然后你可以先暴力枚举一下k，就是行切0~min(n-1,k)刀，列切min(m-1,k)~0刀，输出结果。之后就可以看出答案其实就在行切尽量多刀，和列切尽量多刀

的两个值之间取最大值。

如果想推数学公式的话，貌似还是还有的。这里就不说了，因为没再研究下去。。

D：感谢杰神指点。

题意：

一个国家，共有n个城市，首都在编号为1的城市，然后就是m条路（双向），k条铁路（单向，仅从首都往城市开）。现在要你求出，从首都出发，在不低于当前状态到达每个城市的最短距离的情况下，所能删除的最大铁路数量，并将其输出。数据保证至少有一种方法可以到达每个城市。

思路：

cot[i]：用来保存到达i城市的最短路的方法数。

首先是Dijkstra跑最短路，从首都出发，求出到每个城市的最短路（跑最短路时要包含火车的线路，当时我还以为是至少有一条路可以到达每个城市）。同时在求最短路的过程中维护cot数组。//原来我当时写的Dijkstra是这么挫的，找下个更新点居然是用遍历。。。正确的姿势是用优先队列。

cot数组更新规定：//其实不难的，想想就会觉得很合理

1.如果dis[v] 〉dis[u] + （u，v之间的距离），则cot[v] = cot[u]；

2.如果dis[v] = dis[u] +（u，v之间的距离），则cot[v] += cot[u]；

得到cot数组后，

if火车的距离〉dis[v]，则res ++; //这里不需要cot[v]--，因为cot[v]里面保存的是最短距离的方法数，这里火车到达该城市的距离不是最短距离。

if火车的距离 == dis[v] 并且 cot[v] > 1 ,则{res ++， cot[v] --}；

最后输出res。

注意点：

1.cot的数据可能很大，long long 都有可能放不下。但铁路数最大也才10^5，因此cot太大也是没有意义的，可以直接设置一个比10^5大的值就可以了。

2.dis数组保存到每个城市的最短距离，因此数据比较大，所以最好用long long类型。

A：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;
const int MAXN = 105;
int a[MAXN];
int n, m;
int main()
{
    while(scanf("%d%d", &n ,&m) != EOF)
    {
        int res = 0;
        int tmp, MAX = -1;
        for(int i = 0;i < n; i++)
        {
            scanf("%d", &tmp);
            MAX = max(MAX, tmp);
            a[i] = tmp / m + (tmp%m != 0 ? 1:0);
        }
        int t = -1;
        for(int i = 0;i < n;i++)
        {
            if(t <= a[i])
            {
                res = i + 1;
                t = a[i];
            }
        }
        if(MAX <= m)
        {
            cout<<n<<endl;
            continue;
        }
        cout<<res<<endl;
    }
    return 0;
}

B：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <string>
#define ll long long
using namespace std;

const long long MOD = 1000000007;
long long x, y;
long long n;
long long getRes(ll p)
{
    long long tmp = p;
    while(tmp < 0)
    {
        tmp += MOD;
        tmp %= MOD;
    }
    return tmp % MOD;
}
int main()
{
    while(cin>>x>>y)
    {
        //long long tt = -(2*1e9);
        long long f3 = y - x;
        long long res;
        cin>>n;
        if(n == 1)  {cout<<getRes(x)<<endl;continue;}
        if(n == 2)  {cout<<getRes(y)<<endl;continue;}
        if(n == 3)  {cout<<getRes(y-x)<<endl;continue;}

        long long yushu = n % 3;
        long long chushu = n / 3;

        if(yushu == 0)      //3 de beishu .
        {
            if(chushu % 2 != 0)
                cout<<getRes(f3)<<endl;
            else
                cout<<getRes(f3*-1)<<endl;
        }
        else if(yushu == 1)
        {
            if(chushu % 2 != 0 && n != 1)
                cout<<getRes(-1*x)<<endl;
            else
                cout<<getRes(x)<<endl;
        }
        else
        {
            if(chushu % 2 != 0 && n != 2)
                cout<<getRes(y*-1)<<endl;
            else
                cout<<getRes(y)<<endl;
        }
    }
    return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;
#define ll long long
ll n, m, k;
ll hang()
{
        ll kanhang = min(n-1, k);
        ll kanlie = k - kanhang;
        return (n/(kanhang+1)) * ( m/(kanlie+1));
}
long long lie()
{
        ll kanlie = min(m-1, k);
        ll kanhang = k - kanlie;
        return (m/(kanlie+1)) * (n/(kanhang+1));
}
int main()
{
        while(scanf("%I64d%I64d",&n, &m) != EOF)
        {
                scanf("%I64d",&k);
                if(n + m -2 < k){
                        cout<<"-1"<<endl;
                        continue;
                }
                ll res1 = hang();
                ll res2 = lie();
                cout<<max(res1, res2)<<endl;
        }
        return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#define debug cout<<"debug"<<endl;
#define ll long long
using namespace std;

const int MAXNODE = 1e5 + 5;
const int INF = 0x3f3f3f3f;

struct Road
{
        int v, len;
};
struct Train
{
        int v, len;
};
int n, m, k;
vector <Road> G[MAXNODE];
vector <Train> route;
priority_queue<pair<ll, int> > que;
ll dis[MAXNODE];
ll cot[MAXNODE];
bool vis[MAXNODE];
void input()
{
        int u, v, len;
        for(int i = 0;i < m; i++)
        {
                cin>>u>>v>>len;
                G[u].push_back((Road){v, len});
                G[v].push_back((Road){u, len});
        }
        u = 1;
        for(int i = 0;i < k; i++)
        {
                cin>>v>>len;
                route.push_back((Train){v, len});
                G[u].push_back((Road){v, len});
                G[v].push_back((Road){u, len});
        }
}
void init()
{
        //debug;
        for(int i = 1;i <= n; i++)
            G[i].clear();
        route.clear();
        memset(cot, 0, sizeof(cot));
        memset(dis, INF, sizeof(dis));//or set to -1;
        memset(vis, false, sizeof(vis));
}
void Dijkstra(int tt)
{
    que.push(make_pair(0 * -1, tt));
    dis[tt] = 0;
    cot[tt] = 1;
    while(!que.empty())
    {
        //que.top().first;
        //que.top().second;
        ll val = -que.top().first;
        int u = que.top().second;
        que.pop();
        if(vis[u])  continue;
        vis[u] = true;
        for(int i = 0;i < G[u].size(); i++)
        {
            Road& e = G[u][i];
            if(dis[e.v] == val + e.len)
            {
                cot[e.v] += cot[u];
                if(cot[e.v] > 1e8)
                {
                    cot[e.v] = 1e8;
                }
                //que.push(make_pair(dis[e.v] * -1, e.v));
            }
            else if(dis[e.v] > val + e.len)
            {
                cot[e.v] = cot[u];
                dis[e.v] = val + e.len;
                que.push(make_pair(dis[e.v] * -1, e.v));
            }
        }

    }
    //for(int i = 1;i <= n; i++)  printf("%I64d ",dis[i]);  puts("");
}

ll Charge()
{
        //Train& e = route;
        /*for(int i = 1;i <= n; i++)
        {
            printf("%d ",dis[i]);
        }
        puts("");*/
        ll res = 0;
        for(int i = 0;i < route.size(); i++)
        {
            int v = route[i].v;
            int len = route[i].len;
            if(len > dis[v])    res++;
            else if((len == dis[v] && cot[v] > 1))
            {
                cot[v] --;
                res++;
            }
        }
        return res;
}
int main()
{
        while(scanf("%d%d%d", &n, &m, &k) != EOF)
        {
                init();
                input();
                Dijkstra(1);
                ll res = Charge();
                cout<<res<<endl;
        }
        return 0;
}