2018.09.08 DL24 Day1 总结

补一下之前的总结……

T1.restaurant

这道题还是很简单的嘛，子恒dalao非常良心。我们把招牌菜和所需要的菜品绑定在一起就成了完全背包，然后直接跑一遍完全背包即可。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<queue>
#include<set>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('\n')

using namespace std;
typedef long long ll;
const int M = ;

ll read()
{
    ll ans = ,op = ;
    char ch = getchar();
    while(ch < '' || ch > '')
    {
    if(ch == '-') op = -;
    ch = getchar();
    }
    while(ch >= '' && ch <= '')
    {
    ans *= ;
    ans += ch - '';
    ch = getchar();
    }
    return ans * op;
}

ll T,n,m,t[M],tmax,w[M],x,dp[M];

int main()
{
    freopen("restaurant.in","r",stdin);
    freopen("restaurant.out","w",stdout);
    T = read();
    while(T--)
    {
    memset(dp,,sizeof(dp));
    n = read(),m = read(),tmax = read();
    rep(i,,n) t[i] = read(),w[i] = read();
    rep(i,,m) t[n+i] = read(),w[n+i] = read();
    rep(i,,m)
    rep(j,,n) x = read(),t[n+i] += x * t[j];
    rep(i,,n+m)
    {
        rep(j,t[i],tmax) dp[j] = max(dp[j],dp[j-t[i]] + w[i]);
    }
        printf("%lld\n",dp[tmax]);
    }
    return ;
}
      

T2.olefin

这道题当时想了60分暴力，反正就是直接从一个点开始向两边暴搜即可。

然后有20分是可以固输的，还有40分直接暴力，于是就得了60.

然后这道题的正解是换根DP，就是我们先求出一个点所在子树深度最大的点的深度，然后再记录fromroot表示从根来的最长链的长度，首先一遍dfs求出深度之后，我们对于每个点用fromroot更新其儿子的答案，然后更新它儿子的fromroot。

之后我们对于每一个点找出儿子之中深度最大的和次大的，用次大更新最大，最大更新其他即可。

60分暴力：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<queue>
#include<set>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('\n')

using namespace std;
typedef long long ll;
const int M = ;

int read()
{
    int ans = ,op = ;
    char ch = getchar();
    while(ch < '' || ch > '')
    {
    if(ch == '-') op = -;
    ch = getchar();
    }
    while(ch >= '' && ch <= '')
    {
    ans *= ;
    ans += ch - '';
    ch = getchar();
    }
    return ans * op;
}

struct edge
{
    int next,to,from;
}e[M<<];

int id,n,m,ecnt,head[M],t,sum,maxn,x,dis[M];
bool vis[M];

void add(int x,int y)
{
    e[++ecnt].to = y;
    e[ecnt].next = head[x];
    head[x] = ecnt;
}

void dfs(int x)
{
    dis[x] = ,vis[x] = ;
    int maxm = ;
    bool flag = ;
    for(int i = head[x];i;i = e[i].next)
    {
    if(vis[e[i].to]) continue;
    if(e[i].to > n) continue;
    dfs(e[i].to);
    flag = ;
    maxm = max(maxm,dis[e[i].to]);
    }
    if(flag) dis[x] += maxm,dis[x]++;
}

void naive(int x)
{
    rep(i,,n) vis[i] = ;
    int k = ((x-)<<)-;
    int r1 = e[k].to,r2 = x;
    //printf("#%d %d\n",r1,r2);
    vis[r1] = vis[r2] = ;
    dfs(r1);
    vis[r1] = vis[r2] = ;
    dfs(r2);
    //printf("!%d %d\n",dis[r1],dis[r2]);
    printf("%d ",dis[r1] + dis[r2] + );
}

int main()
{
    freopen("olefin.in","r",stdin);
    freopen("olefin.out","w",stdout);
    id = read();
    t = read();
    while(t--)
    {
    n = read(),m = read();
    ecnt = ;rep(i,,n) head[i] = ;
    rep(i,,n<<) e[i].next = e[i].to = ;
    rep(i,,n) x = read(),add(i,x),add(x,i);
    rep(i,,m)
    {
        x = read();
        if(id == ) printf("%d ",n-);
        else if(id == ) printf("2 ");
        else naive(x);
    }
    enter;
    }
    return ;
}
      

100分：

#include <bits/stdc++.h>
#define enter putchar('\n')
#define space putchar(' ')
#define pii pair<int,int>
#define fi first
#define se second
#define MAXN 100005
#define pb push_back
#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = ;T f = ;char c = getchar();
    while(c < '' || c > '') {
        if(c == '-') f = -;
        c = getchar();
    }
    while(c >= '' && c <= '') {
        res = res *  + c - '';
        c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < ) {x = -x;putchar('-');}
    if(x >= ) out(x / );
    putchar('' + x % );
}
int N,M,fa[MAXN];
int dp[MAXN],ans[MAXN],fr[MAXN];
struct node {
    int to,next;
}E[MAXN * ];
int head[MAXN],sumE;
void add(int u,int v) {
    E[++sumE].to = v;
    E[sumE].next = head[u];
    head[u] = sumE;
}
void dfs1(int u) {
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        dfs1(v);
        dp[u] = max(dp[v] + ,dp[u]);
    }
}
void dfs2(int u) {
    pii p(,);
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        ans[v] = max(dp[v] +  + fr[u],ans[v]);
        fr[v] = max(fr[v],fr[u] + );
        if(dp[v] >= dp[p.se]) p.se = v;
        if(dp[p.se] >= dp[p.fi]) swap(p.se,p.fi);
    }
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        if(v != p.fi) {
            ans[v] = max(dp[v] +  + dp[p.fi],ans[v]);
            fr[v] = max(fr[v],dp[p.fi] + );
        }
        else if(p.se) {
            ans[p.fi] = max(ans[p.fi],dp[p.fi] +  + dp[p.se]);
            fr[p.fi] = max(fr[p.fi],dp[p.se] + );
        }
        dfs2(v);
    }
}
void Solve() {
    memset(head,,sizeof(head));sumE = ;
    memset(fr,,sizeof(fr));memset(dp,,sizeof(dp));memset(ans,,sizeof(ans));
    read(N);read(M);
    for(int i =  ; i <= N ; ++i) {
        read(fa[i]);
        add(fa[i],i);
    }
    dfs1();dfs2();
    int x;
    for(int i =  ; i <= M ; ++i) {
        read(x);out(ans[x]);
        if(i == M) enter;
        else space;
    }
    if(!M) enter;
}
int main() {
    freopen("olefin.in","r",stdin);
    freopen("olefin.out","w",stdout);
    int id,T;
    read(id);read(T);
    while(T--) {
        Solve();
    }
    return ;
}

T3.tromino

这道题当时自己确实不知道该怎么做啊……

后来听了讲解竟然要分成那么多情况……我们考虑当左侧都填满的时候右侧有多少种填充情况。一共有九种，然后考虑在这个基础上把左边那一列填满，然后把这个3*2的窗口向右移动一列，看他们的变化情况……

然后你发现每步的移动都是一样的，你就能得到一个9*9的矩阵。

如果你使用OEIS网站或者高斯消元……可以把其简化为一个6*6矩阵，然后转移即可……

其实这道题的递推公式可以在OEIS上搜到的。

哦，然后因为这题的数据范围过大，即使是快速幂也满足不了需求，所以我们使用十进制快速幂，也就是每次把这个数一位一位的去进行快速幂即可，然后每次要乘上当前矩阵的10次幂。

看一下std，自己改过的代码找不到了……

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;

const int tb[][] = {
    {, , , , , },
    {, , , , , },
    {, , , , , },
    {, , , , , },
    {, , , , , },
    {-, , , , , },
};
const int pre_ans[] = {, , , , , };

const int N = , P = ;
char s[N];
int n, a[N];

struct matrix {
    ll g[][];
    matrix(){
        memset(g, , sizeof(g));
    }
    matrix operator * (const matrix &b) const {
        matrix c;
        for(int i = ; i < ; i++)
            for(int j = ; j < ; j++)
                for(int k = ; k < ; k++)
                    c.g[i][j] = (c.g[i][j] + g[i][k] * b.g[k][j]) % P;
        return c;
    }
} mtx, ans, tmp, pw[];

int main(){

    scanf("%s", s);
    n = strlen(s);
    if(n ==  && s[] < ''){
        printf("%d\n", pre_ans[s[] - '']);
        return ;
    }
    for(int i = ; i < n; i++)
        a[i] = s[n - i - ] - '';
    a[] -= ;
    for(int i = ; a[i] < ; i++)
        a[i] += , a[i + ]--;
    while(n && a[n - ] == ) n--;
    for(int i = ; i < ; i++)
        for(int j = ; j < ; j++)
            mtx.g[i][j] = tb[i][j];
    for(int i = ; i < ; i++)
        pw[].g[i][i] = ;
    for(int i = ; i <= ; i++)
        pw[i] = pw[i - ] * mtx;
    ans = pw[];
    for(int i = n - ; i >= ; i--){
        tmp = ans = ans * ans;
        ans = ans * ans;
        ans = ans * ans * tmp * pw[a[i]];
    }
    for(int i = ; i < ; i++)
        mtx.g[i][] = pre_ans[i];
    ans = ans * mtx;
    printf("%lld\n", ans.g[][]);

    return ;
}