暑假集训日记（四）（长题解）

昨天做大的事情应该是西安邀请赛的重现，4题；

A。字符串基本处理。

求有多少DOGE

#include <cctype>  
#include <cstdio>  
using namespace std;  
  
const int maxLen = (1 << 16);  
char buffer[maxLen];  
int len, res;  
  
inline bool isDOGE(int i)  
{  
    return  (toupper(buffer[i]) == 'D') &&  
            (toupper(buffer[i + 1]) == 'O') &&  
            (toupper(buffer[i + 2]) == 'G') &&  
            (toupper(buffer[i + 3]) == 'E');  
}  
  
void solve()  
{  
    char ch = 0;  
    while (~scanf("%c", &ch)) buffer[len++] = ch;  
    len -= 3;  
    for (int i = 0; i < len; i++)  
        if (isDOGE(i))  
            res++;  
    printf("%d\n", res);  
}  
  
int main()  
{  
    solve();  
    return 0;  
}  

C题

用三个数组，生成一个二维数组的图，然后二维数组是点与点的最短路径。利用的是三个公式

我用的SPFA直接把数组弄出来，然后对于数组dis每个余m,排序一下，输出第一个元素即可。

/*#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<queue>
#include<set>
#include<vector>
#include<string>
#include<ctime>
#include<string.h>
using namespace std;
//#define LL __int64
typedef long long LL;
#define INF 0x7fffffffffffffff
#define bug puts("hear!")
#define inf 0x7fffffff
#define eps 1e-10
#define N 3000000
#define FRE freopen("in.txt","r",stdin)
#define E exp(1.0)
#define mod 1000000007
LL modexp_recursion(LL a,LL b,LL n)//快速幂
{
    LL t = 1;
    if (b == 0)
        return 1;
    if (b == 1)
         return a%n;
    t = modexp_recursion(a, b>>1, n);
    t = t*t % n;
    if (b&0x1)
        t = t*a % n;
    return t;
 }
 LL phi[3000001];
 LL a,b,c,d;
 int quick_oula()//快速欧拉函数
 {
    int i,j;
    for(i=1;i<3000001;i++)
        phi[i]=i;
    for(i=2;i<3000001;i++)
    {
        if(phi[i]==i)
        {
            for(j=i;j<3000001;j+=i)
            {
                phi[j]=(phi[j]/i)*(i-1);
            }
        }
    }
 }
 void print(int x)//打印N进制数
 {
    if(x<=9)
        cout<<x;
    else
        printf("%c",x-10+'A');
 }
 void change(LL n,int r){//10进制转换N进制
    if(n)
    {
        change(n/r,r);
        print(n%r);
    }
 }
int f(char n)//单个16进制数转10进制
{
    if('A'<=n&&n<='F')
        return 10+(n-'A');
    else

        return n-'0';
}
LL fq(char s[])//16进制数赚10进制
{
    int i=0;
    LL sum=0;
    if(s[0]=='-')
        i++;
    if(s[0]=='+')
    i++;
    for(;s[i]!='\0';i++)
    {
      sum*=16;
      sum+=f(s[i]);
    }
    return sum;
}
int main(){
    int f[100000001];
LL q;
f[0]=1;
f[1]=5;
for(int i=2;i<=100000000;i++)
{
    if((i-5)%6==0)
        f[i]=0;
    else
    {

    }
}
    return 0;
}*/
/*
#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<queue>
#include<set>
#include<vector>
#include<string>
#include<ctime>
#include<string.h>
using namespace std;
//#define LL __int64
typedef long long ll;
#define INF 0x7fffffffffffffff
#define bug puts("hear!")
#define inf 0x7fffffff
#define eps 1e-10
#define N 3000000
#define FRE freopen("in.txt","r",stdin)
#define E exp(1.0)
#define mod 1000000007
const int maxn=1005;
const int maxm=1000005;
const ll mod1=5837501;
const ll mod2=9860381;
const ll mod3=8475871;
int n,m,x,xz,y,yz;
ll dis[maxn];
ll a[maxm],b[maxm],c[maxm],d[maxn][maxn];
bool  visit[maxn];
inline ll gongshi1(int k){
    return (12345 + a[k-1] * 23456 + a[k-2] * 34567 + a[k-1] * a[k-2] * 45678)% mod1;
}
inline ll gongshi2(int k)
{
    return (56789 + b[k-1] * 67890 + a[k-2] * 78901 + b[k-1] * b[k-2] * 89012)  %  mod2;
}
void SPFA(){
    for(int i=0;i<n;i++)
        dis[i]=1LL<<62;
    dis[0]=0;
    for(int i=0;i<n;i++)
        visit[i]=false;
    visit[0]=true;
    queue<ll>q;
    q.push(0);
    while(!q.empty())
    {
       int i=q.front();
       q.pop();
       visit[i]=false;
        for(int j=0;j<n;j++)
        {
           if(dis[j]>dis[i]+d[i][j])
           {
               dis[j]=dis[i]+d[i][j];
               if(!visit[j])
               {
                   visit[j]=true;
                   q.push(j);
               }
           }
        }
    }
}
int main(){
    while(~(scanf("%d %d %d %d %d %d",&n,&m,&x,&xz,&y,&yz)))
    {
        a[0]=x;a[1]=xz;
        b[0]=y,b[1]=yz;
        for(int k=2;k<n*n;k++)
        {
           a[k]=gongshi1(k);
           b[k]=gongshi2(k);
        }
        for(int k=0;k<n*n;k++)
        {
            c[k]=(a[k] * 90123 + b[k] )%mod3 + 1;
        }
        for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (i != j)
                d[i][j] = c[i * n + j];
            else
                d[i][j] = 0;
    SPFA();
    for (int i = 0; i < n; i++)
        dis[i] %= m;
    sort(dis + 1, dis + n);
    cout << dis[1] <<endl;
    }
    return 0;
}*/
#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;

typedef long long int64;

const int maxN = 1005;
const int maxM = 1000005;
const int64 xmod = 5837501;
const int64 ymod = 9860381;
const int64 zmod = 8475871;

int n, m, n2;
int x0, x1, y0, y1;
int64 x[maxM], y[maxM], z[maxM], c[maxN][maxN];
int64 dis[maxN];
bool inqueue[maxN];

inline int64 calcx(int k)
{
    return (12345 + x[k - 1] * 23456 + x[k - 2] * 34567
        + x[k - 1] * x[k - 2] * 45678) % xmod;
}

inline int64 calcy(int k)
{
    return (56789 + y[k - 1] * 67890 + y[k - 2] * 78901
        + y[k - 1] * y[k - 2] * 89012) % ymod;
}

void SPFA()
{
    for (int i = 0; i < n; i++)
        dis[i] = 1LL << 62;
    dis[0] = 0;
    for (int i = 0; i < n; i++)
        inqueue[i] = false;
    inqueue[0] = true;
    queue<int64> q; q.push(0);
    while (!q.empty())
    {
        int i = q.front(); q.pop();
        inqueue[i] = false;
        for (int j = 0; j < n; j++)
            if (dis[j] > dis[i] + c[i][j])
            {
                dis[j] = dis[i] + c[i][j];
                if (!inqueue[j])
                {
                    inqueue[j] = true;
                    q.push(j);
                }
            }
    }
}

int64 solve()
{
    x[0] = x0; x[1] = x1;
    y[0] = y0; y[1] = y1;
    for (int k = 2; k < n * n; k++)
        x[k] = calcx(k), y[k] = calcy(k);
    for ( int k = 0; k < n * n; k++)
        z[k] = (x[k] * 90123 + y[k]) % zmod + 1;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (i != j)
                c[i][j] = z[i * n + j];
            else
                c[i][j] = 0;
    SPFA();
    for (int i = 0; i < n; i++)
        dis[i] %= m;
    sort(dis + 1, dis + n);
    cout << dis[1] << endl;
}

int main(){
    while ( cin >> n >> m >> x0 >> x1 >> y0 >> y1 )
        solve();
    return 0;
}

D题 题目要求，你做一个长度为n的字符串，其中如果n>=4，那么长度为4以上的子串不能有任何一个相同。

首先肯定4位4位一生成一个子串，然后子串连接起来这么算。

那么，对于一个4位的子串，那么就是有26^4种解法。恰巧，这个就是答案。当然,这个答案后面要加上2个‘a’和一个'\0'。这个先不说

其次，对于每一个4位，当然不能全排列。一共是467976种吧。。。

看大神的题解是dfs搞，MD居然能这么搞也是学习了一下。

当然就是按照题目的限定条件深搜一下，能出来，只不过时间是700+MS

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const char* alpha = "abcdefghijklmnopqrstuvwxyz";
const int asz = 26;
const int maxN = 500000;
int maxS, len, s, state[4 * asz + 13];
char result[maxN];

int dfs(int curr, int prev)
{
    if (len >= maxN) return 0;
    if (curr > 4)//catch char
    {
        if (4 % prev == 0)
        {
            for (int i = 1; i <= prev; i++)
            {
                result[len++] = state[i];
                if (len >= maxN) break;
            }
        }
    }
    else
    {
        int stateID = state[curr - prev];
        state[curr] = stateID;
        dfs(curr + 1, prev);
        for (int i = stateID + 1; i < 26; i++)
        {
            state[curr] = i;
            dfs(curr + 1, curr);
        }
    }
    return 0;
}

inline void addStringaaa()
{
    result[len] = result[len + 1] = result[len + 2] = 'a';
    result[len + 3] = '\0';
    maxS = len + 3;
}

void solve()
{
    if (s > maxS) puts("Impossible");
    else
    {
        for (int i = 0; i < s; i++)
            printf("%c", result[i]);
        puts("");
    }
}

int main()
{
    dfs(1, 1);
    for (int i = 0; i < len; i++)
        result[i] = alpha[result[i]];
    addStringaaa();
    while (~scanf("%d", &s))
        solve();
    return 0;
}

J题，摆明了是个状态压缩dp。。。

不知道大家有没有玩过传送门这个游戏，这道题就是那个意思，有几个门可以传送。就是x->y的传送，然后问你需要遍历所有的传送门需要的最短时间是多少。

dp公式就是

f[j][mask ^ (1 << (j - 1))] = min(f[j][mask ^ (1 << (j - 1))], f[i][mask] + cost[i][j]);

/*
@Suvigo
*/
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxN = 25;
const int maxM = 21;
const int inf  = 500000000;
int n, m, tot, a[maxN * maxN][maxN * maxN];
int cost[maxM][maxM], f[maxM][1 << maxM];
bool bar[maxN][maxN];
char str[maxN];
pair <int, int> tunnel[maxM];

inline int encode(int x, int y)
{
    return (x - 1) * n + y;
}

void DataScanner()
{
    for (int i = 1; i <= n; i++) bar[i][i] = false;
    tot = n * n;
    for (int i = 1; i <= n; i++)
    {
        scanf("%s", str + 1);
        for (int j = 1; j <= n; j++)
        {
            if (str[j]=='#') bar[i][j] = true;
            else bar[i][j] = false;
        }
    }
    int x1, x2, y1, y2;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d%d",  &x1,  &y1,  &x2,  &y2);
        tunnel[i] = make_pair(encode(x1, y1), encode(x2, y2));
    }
}

void Build()
{
    for (int i = 1; i <= tot; i++)
        for (int j = 1; j <= tot; j++)
            a[i][j] = inf;
    for (int i = 1; i <= tot; i++)
        a[i][i] = 0;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (bar[i][j]) continue;
            if (j < n && !bar[i][j + 1])
                a[encode(i, j)][encode(i, j + 1)] = a[encode(i, j + 1)][encode(i, j)] = 1;
            if (i < n && !bar[i + 1][j])
                a[encode(i, j)][encode(i + 1, j)] = a[encode(i + 1, j)][encode(i, j)] = 1;
        }
    }
}

void Floyd()
{
    for (int k = 1; k <= tot; k++)
        for (int i = 1; i <= tot; i++)
            for (int j = 1; j <= tot; j++)
                a[i][j] = min(a[i][j], a[i][k]+a[k][j]);
}

void DP()
{
    for (int i = 1; i <= m; i++)
        for (int j = 1;j <= m;j++)
            if (i == j) continue;
            else
                cost[i][j] = a[tunnel[i].second][tunnel[j].first];
    for (int i = 1; i <= m; i++)
        for (int j = 0; j<(1 << m); j++)
            f[i][j] = inf;
    for (int i = 1; i <= m; i++)
        f[i][1 << (i-1)] = 0;
    for (int mask = 0; mask < (1 << m); mask++)
    {
        for (int i = 1; i <= m; i++)
        {
            if (!(mask & (1 << (i - 1)))) continue;
            for (int j = 1;j <= m;j++)
            {
                if (mask & (1 << (j - 1))) continue;
                f[j][mask ^ (1 << (j - 1))] = min(f[j][mask ^ (1 << (j - 1))], f[i][mask] + cost[i][j]);
            }
        }
    }
    int ans = f[1][(1 << m)-1];
    for (int i = 2; i <= m; i++) ans = min(ans, f[i][(1 << m)-1]);
    if (ans >= inf) printf("-1\n");
    else printf("%d\n", ans);
}

void solve()
{
    DataScanner();
    Build();
    Floyd();
    DP();
}

int main()
{
    while (~scanf("%d%d", &n, &m))
        solve();
    return 0;
}

晚上玩最短路径问题，发现HDU2544和3790完全尼玛是一道题啊，就是改了一两个地方。。。。。囧