今日头条”杯2018年湖北省赛(网络赛)

所有题目： http://cdn.vo-ov.cn/online_f9ec217.pdf

 

F: A-maze-ing（tarjan+缩点dfs找最长链）

哇我也是哭了...dfs写错，dfs还用了vis数组，实际上并不需要，WA了N多次...呜呜呜

看出来对图的基本概念还比较生疏，或者说都忘了好多，一开始还在纠结环是不是强连通分量...唉如果能果断点就好了

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <set>
#include <cstring>
#include <algorithm>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxn = 2e5+5;
const int maxk = 200;

struct edge {
    int to, next;
}edges[maxn];

struct edg{
    int to, next;
}e[maxn];

int N, M, cnt, sum;
int order, iindex;
int linjie[maxn], linjie_2[maxn], indeg[maxn], LOW[maxn];
int DFN[maxn], belong[maxn], Stack[maxn];
int num[maxn];
bool vis[maxn];


void addedge( int u, int v )
{
    edges[cnt].to = v; edges[cnt].next = linjie[u]; linjie[u] = cnt++; }

void addedge_2( int u, int v )
{ 
    e[cnt].to = v; e[cnt].next = linjie_2[u]; linjie_2[u] = cnt++; }

void init()
{
    cnt = order = iindex = sum = 0;
    memset( linjie, -1, sizeof(linjie) );
    memset( linjie_2, -1, sizeof(linjie_2) );
    memset( indeg, 0, sizeof(indeg) );
    memset( LOW, 0, sizeof(LOW) );
    memset( DFN, 0, sizeof(DFN) );
    memset( belong, 0, sizeof(belong) );
    memset( Stack, 0, sizeof(Stack) );
    memset( num, 0, sizeof(num) );
    memset( vis, 0, sizeof(vis) );
}

void tarjan( int x )
{
    DFN[x] = LOW[x] = ++order;
    Stack[++iindex] = x;
    vis[x] = true;
    for( int i = linjie[x]; i+1; i = edges[i].next )
    {
        if (!DFN[edges[i].to])
        {
            tarjan(edges[i].to);
            LOW[x] = Min( LOW[x], LOW[edges[i].to] );
        }
        else if ( vis[edges[i].to] )
            LOW[x] = Min( LOW[x], DFN[edges[i].to] );
    }

    if ( LOW[x] == DFN[x] )
    {
        sum++;
        while( iindex )
        {

            int temp = Stack[iindex--];
            vis[temp] = false;
            belong[temp] = sum;
            if ( temp == x )
                break;
        }
    }
}

void solve()
{
    cnt = 0;

    for ( int i = 1; i <= N; i++ )
        num[belong[i]]++;

    for ( int i = 1; i <= N; i++ )
        for ( int j = linjie[i]; j+1; j = edges[j].next )
            if ( belong[i] != belong[edges[j].to] )
            {
                indeg[belong[edges[j].to]] = 1;
                addedge_2(belong[i], belong[edges[j].to]);
            }
}

void read()
{
    int x, y;
    for ( int i = 1; i <= M; i++ )
    { 
        scanf("%d %d", &x, &y); 
        addedge(x, y);
    }
}

void find( int x )
{
    if ( linjie_2[x] == -1 )
    {
        belong[x] = num[x];
        return;
    }


    for ( int i = linjie_2[x]; i+1; i = e[i].next )
    {
        if (!belong[e[i].to])
            find(e[i].to);
        belong[x] = Max( belong[x], belong[e[i].to]+num[x] );
    }
    
    return;
}

int main()
{
    while (~scanf("%d %d", &N, &M))
    {
        init();
        read();

        for (int i = 1; i <= N; i++)
            if (!DFN[i])
                tarjan(i);
        solve();

        int ans = 0;
        memset( belong, 0, sizeof(belong) );

        for (int i = 1; i <= sum; i++)
            if (!indeg[i])
            {
                find(i);
                ans = Max(ans, belong[i]);
            }

        printf("%d\n", ans);
    }
    return 0;
}

 

E：Jump a Jump

其实这是一类套路题...比赛时满脑子都是dpdpdp...实际上这类题目应该是用图论来做...这tm谁想到的啊？？ 

有一道相似的题目UESTC 1633 都是最短路来做，看一下那道题就知道这题该怎么做了，算法一样，只是最后求答案时判断不一样

实际上比如得到的m个数分别为a1~am，再假如x是这m个数构造任意出来的，那么x+a1一定也是可以被构造出来的

因为每个数字可以取无限次，那么只要选取一个最小的数（其实选任意数都可以，不过选最小可以让时间最优），假设是a1，再设一个数组dis[i]，(0=< i <a1)表示构造一个mod（a1）等于i时可得到的最小值

比如一共两个数字a1=3， a2 = 4。那么最小的数min = 3

所以dis[0]等于0， 因为a1 mod min = 0

dis[1]等于4， 因为4mod min = 1， 而4显然可以被构造（虽然7mod min也等于1，而且也可被3和4构造出来，但是7比4大，所以最小的可以被构造的数是4）

dis[2]等于8， 因为虽然5mod min = 2，但是5没办法被3和4构造，然后8mod min = 2，8显然可以被构造，所以dis[2]=8

这样做有什么用呢，其实发现只要求了所有dis[i]，那么这些 数字全部能构造的数都可以表示成dis[i]+k*a1，自己想想就知道接下来怎么求答案了

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <set>
#include <cstring>
#include <algorithm>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
//const int mod  = 7;
const int maxn = 5005;
const int maxk = 5005;

struct edges {
    LL x, d;
    edges() { }
    edges( LL lg, LL id )
        : x(lg), d(id) { }
};

LL m, M;
LL mod, dis[maxn];
LL num[maxn];;
bool vis[maxn];

void dijkstra()
{
    memset( vis, 0, sizeof(vis) );
    for ( int i = 0; i < mod; i++ )
        dis[i] = INF;
    dis[0] = 0;

    int mark;
    LL mindis;
    for ( int i = 0; i < mod; i++ )
    {
        mark = -1; mindis = INF;
        for ( int j = 0; j < mod; j++ )
            if ( !vis[j] && dis[j] < mindis )
            {
                mindis = dis[j];
                mark = j;
            }
        //cout << mark << endl;

        vis[mark] = true;

        for ( int j = 0; j < m; j++ )
            if ( (num[j] + mindis) < dis[(num[j] + mindis) % mod] )
            {
                dis[(num[j] + mindis) % mod] = num[j] + mindis;
            }
    }
}

int main()
{
    while ( ~scanf("%lld", &M ) )
    {
        cin >> m;

        mod = maxn;
        for ( int i = 0; i < m; i++ )
        {
            scanf( "%lld", &num[i] );
            mod = LMin(mod, num[i]);
        }

        dijkstra();


        LL ans = INF;
        for ( int i = 0; i < mod; i++ )
        {
            if ( dis[i] >= M )
                ans = LMin( ans, dis[i] - M );
            else
            {
                LL x = (M-dis[i])%mod;
                LL y = LMin( x, mod - x );
                ans = LMin( ans, y );
            }
        }
        printf( "%lld\n", ans );
    }

    return 0;
}

 

H：GSS and OJ Submissions（分块）

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <set>
#include <vector>
#include <cstring>
#include <algorithm>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;
typedef unsigned long long uLL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 5005;
const int maxn = 2e6;
const uLL ddiv = 1e14;

uLL A, B, L, n, s0;
int block[maxn];
vector<uLL> vec;

int main()
{
    scanf( "%llu%llu%llu%llu%llu", &A,&B,&L,&n,&s0 );
    uLL tmp = s0;

    block[tmp/ddiv]++;
    for ( int i = 1; i < n; i++ )
    {
        block[tmp/ddiv]++;
        tmp = tmp*A + B;        //通过除以一个大数所得到的商不同来分类
    }

    uLL l = L, pos = 0;
    for ( int i = 0; i < maxn; i++ )
    {
        if ( L > block[i] )            //因为是递增序列，所以可以遍历一遍求的L在哪个块
            L -= block[i];
        else
        {
            pos = i;
            break;
        }
    }

    tmp = s0;
    for ( int i = 1; i <= n; i++ )
    {
        if ( tmp / ddiv == pos )
            vec.push_back(tmp);
        tmp = tmp*A + B;
    }

    sort( vec.begin(), vec.end() ); 
    printf( "%llu\n", vec[L-1] );
    
    return 0;
}