寒假Day16蓝桥杯题4/7+POJ2135Farm Tour（最小费用最大流模板题）

[蓝桥杯2019初赛]数列求值

给定数列1, 1, 1, 3, 5, 9, 17, …，从第4 项开始，每项都是前3 项的和。求
第20190324 项的最后4 位数字。

注意：

• 遇到取后n位数，则%1000...（后面跟n个零）；
• 取后几位数字的时候，注意判断位数、输出前导零。

答案：4659

AC代码：

#include<string.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
typedef long long ll;

int a[20190333];
//int 4659  ll 4659
int main()
{
    a[1]=1;
    a[2]=1;
    a[3]=1;
    a[4]=3;
    for(int i=5;i<=20190324;i++)
    {
        a[i]=a[i-1]+a[i-2]+a[i-3];
        if(a[i]>10000)
            a[i]%=10000;
    }
    int w=a[20190324];
    if(w>=1000&&w<=9999)
        cout<<w<<endl;
    else
    {
        int wei=0,k=w;
        while(k)
            wei++,k/=10;
        for(int i=1;i<=4-wei;i++)
            cout<<"0";
        cout<<w<<endl;
    }
    //w=4659
    return 0;
}

WA代码：（不知道这样写为什么不对？？）

#include<string.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int N=110;
typedef long long ll;

ll a[20190333];
//int 0691 ll 0115;
int main()
{
    a[1]=1;
    a[2]=1;
    a[3]=1;
    a[4]=3;
    for(int i=5;i<=20190324;i++)
        a[i]=a[i-1]+a[i-2]+a[i-3];
    int w=a[20190324]%10000;
    if(w>=1000&&w<=9999)
        cout<<w<<endl;
    else
    {
        int wei=0,k=w;
        while(k)
            wei++,k/=10;
        for(int i=1;i<=4-wei;i++)
            cout<<"0";
        cout<<w<<endl;
    }
    return 0;
}

---

[蓝桥杯2019初赛]数的分解

把2019分解成3个各不相同的正整数之和，并且要求每个正整数都不包含数字2和4，一共有多少种不同的分解方法？
注意交换3个整数的顺序被视为同一种方法，例如1000+1001+18 和1001+1000+18 被视为同一种。

思路： i，j，k相加等于2019，接着把满足条件的存入数组中进行排序、标记判断即可。

注意：题看清楚，题面上给的所有要求都必须在代码中体现出来（仔细检查啊大哥！！！）

　　　像这种交换顺序题意说明还算是同一种的，可以利用排序进行判断，之后再开一个二维数组进行标记就可以嘞。

AC代码:

#include<string.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int N=110;
typedef long long ll;

int a[5];
bool book[2020][2020];

int main()
{
    ll ans=0;
    memset(book,0,sizeof(book));
    for(int i=1; i<=2019; i++)
    {
        for(int j=1; j<=2019; j++)
        {
            int k=2019-i-j;
            if(i==j||i==k||j==k)
                continue;
            if(k>0)
            {
                a[0]=i;
                a[1]=j;
                a[2]=k;
                sort(a,a+3);
                int flag=0;
                for(int kk=0; kk<3; kk++)
                {
                    flag=0;
                    int t=a[kk];
                    while(t)
                    {
                        int tt=t%10;
                        t/=10;
                        if(tt==2||tt==4)
                        {
                            flag=1;
                            break;
                        }
                    }
                    if(flag)
                        break;
                }
                if(!flag&&!book[a[0]][a[1]])
                {
                    book[a[0]][a[1]]=1;
                    ans++;
                }
            }
        }
    }
    cout<<ans<<endl;
    return 0;
}

---

[蓝桥杯2019初赛]立方和

注意：定义的数据范围啊，，，

int的2019的立方溢出了，需要改数据类型，老记不住到时候怎么错的都不知道，这么简单的也错，唉

（ull）i*i*i=2019*2019*2019

AC代码：

#include<string.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int N=110;
typedef long long ll;

int main()
{
    unsigned long long ans=400816;
    int flag=0;
    for(unsigned long long i=41; i<=2019; i++)
    {
        int flag=0;
        int kk=i;
        while(kk)
        {
            int k=kk%10;
            kk/=10;
            if(k==2||k==0||k==1||k==9)
            {
                flag=1;
                break;
            }
        }
        if(flag)
            ans=ans+i*i*i;
    }
    cout<<ans<<endl;
    return 0;
}

---

POJ2135-Farm Tour（最小费用最大流模板题）

题面：

When FJ's friends visit him on the farm, he likes to show them around. His farm comprises N (1 <= N <= 1000) fields numbered 1..N, the first of which contains his house and the Nth of which contains the big barn. A total M (1 <= M <= 10000) paths that connect the fields in various ways. Each path connects two different fields and has a nonzero length smaller than 35,000.

To show off his farm in the best way, he walks a tour that starts at his house, potentially travels through some fields, and ends at the barn. Later, he returns (potentially through some fields) back to his house again.

He wants his tour to be as short as possible, however he doesn't want to walk on any given path more than once. Calculate the shortest tour possible. FJ is sure that some tour exists for any given farm.
Input
* Line 1: Two space-separated integers: N and M.

* Lines 2..M+1: Three space-separated integers that define a path: The starting field, the end field, and the path's length.
Output
A single line containing the length of the shortest tour.

样例：

Sample Input
4 5
1 2 1
2 3 1
3 4 1
1 3 2
2 4 2


Sample Output
6

题意：

给出n个点，m条边，问一个人从家走到barn的最短长度(设家1，barn为N)；
所以，问的就是   去：1->N     和     返：N->1     两条路径的最短长度，两条路径不能重复；
所以，问题变成了：有两个人，从1->N，它们所走路径不能重复（走的边不能重复），求最短长度。

所以变成了最小费用最大流问题，自己再自己想想。

 思路：

我以为是个最短路。。但是最短路貌似好像不能解决路径重复问题叭。。

妥妥的模板，我终于碰到了，原来我先做的都是变形题，我太难了。。

题意转化到算法上还是比较不好想到，怎么分析在上面的题意里面已经写清楚了。

容量cap传入的为1或者2（自己判断传入什么），花费cost即点和点之间的权值。

建边最重要：

        memset(head,-1,sizeof(head));
        tot=0;
        s=0,t=n+1;
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,1,w);
            add(v,u,1,w);
        }
        add(s,1,2,0);
        add(n,t,2,0);
        printf("%d\n",MCMF());

AC代码：

#include<string.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int N=1100;
typedef long long ll;

struct node
{
    int to,nextt;
    int cap,flow,cost;
} e[N*N];

bool book[N];
int pre[10*N],head[10*N],dist[N];
int tot,s,t;

void add(int u,int v,int cap,int cost)
{
    e[tot].to=v;
    e[tot].cap=cap;
    e[tot].cost=cost;
    e[tot].flow=0;
    e[tot].nextt=head[u];

    head[u]=tot++;
    e[tot].to=u;
    e[tot].cap=0;
    e[tot].cost=-cost;
    e[tot].flow=0;
    e[tot].nextt=head[v];
    head[v]=tot++;
}

bool SPFA()
{
    for(int i=0; i<=t; i++)
    {
        dist[i]=inf;
        book[i]=0;
        pre[i]=-1;
    }
    book[s]=1;
    dist[s]=0;
    queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        book[u]=0;
        for(int i=head[u]; i!=-1; i=e[i].nextt)
        {
            int v=e[i].to;
            if(e[i].cap>e[i].flow&&dist[v]>dist[u]+e[i].cost)
            {
                dist[v]=dist[u]+e[i].cost;
                pre[v]=i;
                if(book[v]==0)
                {
                    book[v]=1;
                    Q.push(v);
                }
            }
        }
    }
    if(dist[t]!=inf)
        return 1;
    return 0;
}

int MCMF()
{
    int flow=0,cost=0;
    while(SPFA())
    {
        int minn=inf;
        for(int i=pre[t]; i!=-1; i=pre[e[i^1].to])
            minn=min(minn,e[i].cap-e[i].flow);
        for(int i=pre[t]; i!=-1; i=pre[e[i^1].to])
        {
            e[i].flow+=minn;
            e[i^1].flow-=minn;
            cost+=e[i].cost*minn;
        }
        flow+=minn;
    }
    return cost;
}

int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        memset(head,-1,sizeof(head));
        tot=0;
        s=0,t=n+1;
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,1,w);
            add(v,u,1,w);
        }
        add(s,1,2,0);
        add(n,t,2,0);
        printf("%d\n",MCMF());
    }
    return 0;
}

---

待解决：

上面的数列求值中，为什么这样处理可以，

for(int i=5;i<=20190324;i++)
{
    a[i]=a[i-1]+a[i-2]+a[i-3];
    if(a[i]>10000)
        a[i]%=10000;
}

这样处理就不对，而且开ll和int出来结果也不一样，从后面溢出？？？可是不取余输出前面几位也不是正确答案啊？？？

for(int i=5;i<=20190324;i++)
    a[i]=a[i-1]+a[i-2]+a[i-3];
int w=a[20190324]%10000;