2022-01-12每日刷题打卡

2022-01-12每日刷题打卡

Acwing——y总每日刷题打卡

848. 有向图的拓扑序列 - AcWing题库

给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。

若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。

输入格式

第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。

输出格式

共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。

否则输出 −1。

数据范围

1≤n,m≤10^5

输入样例：

3 3
1 2
2 3
1 3

输出样例：

1 2 3

用数组模拟邻接表的形式，把所有的边都存下来，每次记录边的入读，比如a到b，则b的入度++，开始拓扑排序，遍历所有点的入度，把入度为0的点都存入队列里，然后遍历队列，每次从中取头元素出来，然后把以该点为起点的所有边都找出来，把边的终点的点的入度都–，如果–后等于0，则把它也存入队列。一切结束后，判断队列中存的点是否等于点的数量。如果等于就按照顺序把所有点输出，不等于就返回-1。

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>

const int N=1000010;
int e[N],ne[N],q[N],d[N],h[N],idx,n,m;

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

bool top_sort()
{
    int hh=0,tt=-1;
    for(int i=1;i<=n;i++)
        if(!d[i])q[++tt]=i;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            d[j]--;
            if(!d[j])q[++tt]=j;
        }
    }
    return tt==n-1;
}

int main()
{
    int a,b;
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        cin>>a>>b;
        add(a,b);
        d[b]++;
    }
    if(top_sort())
    {
        for(int i=0;i<n;i++)
        {
            cout<<q[i]<<" ";
        }
    }
    else
        cout<<"-1"<<endl;
}

853. 有边数限制的最短路 - AcWing题库

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500
1≤m≤10000
任意边长的绝对值不超过 10000。

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

输出样例：

3

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>

const int N=510,M=100010;
int n,m,k;
int backup[N],d[N];

struct edg
{
    int a,b,w;
}edge[M];

int bellom_ford()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(backup,d,sizeof(d));
        for(int j=0;j<m;j++)
        {
            int a=edge[j].a,b=edge[j].b,w=edge[j].w;
            d[b]=min(d[b],backup[a]+w);
        }
    }
    if(d[n]>0x3f3f3f3f/2)return -1314520;
    return d[n];
}

int main()
{
    int a,b,w;
    cin>>n>>m>>k;
    for(int i=0;i<m;i++)
    {
        cin>>a>>b>>w;
        edge[i]={a,b,w};
    }
    int t=bellom_ford();
    if(t==-1314520)cout<<"impossible"<<endl;
    else cout<<t<<endl;
    return 0;
}

蓝桥杯——算法提高

Hanoi塔

问题描述

汉诺塔问题是我们所熟知的问题，众所周知，解决N个盘子的汉诺塔问题的最少步骤为2^{N-1，现求2}N % 1000000007的值。

输入格式

一行一个正整数N，意义如题目所示。

输出格式

一行一个正整数，表示2^N % 1000000007

样例输入

10

样例输出

1024

数据规模和约定

0<=N<=2^31-1

一般我们算一个数的n次方，就是把n个数乘起来，比如2^3，就是2 * 2 * 2，由于计算机的限制，我们一步只能算两个数的计算，不能直接写个2 * 2 * 2出来，而是2*2得到4后再 * 2，这样就进行了2次运算，如果按这题来算，最高n可以取到2^31-1次方，如果我们一个个算绝逼要超时，这里我们采用快速幂的思想，就可以把时间复杂度从On变成logn。

快速幂：直接举个例子：比如2的8次方，正常算我们要算n-1=7次，但快速幂是这么算的，2⁸⁼²4*2⁴⁼²2 * 2^2 * 2^2 * 2^{2,你先算得2的2次方等于4，然后4的2次方就是16，16的二次方就是256，这样，我们只用了三步就算得了2}8次方。简单来说就是，我们拿一个低阶的幂去求高阶的幂。

#include<iostream>
using namespace std;

typedef long long ll;

ll quick_squa(ll n)
{
    if (n == 0)return 1;
    else if (n % 2 == 1)return quick_squa(n - 1) * 2 % 1000000007;
    else
    {
        ll temp = quick_squa(n / 2)% 1000000007;
        return temp * temp % 1000000007;
    }
}

int main()
{
    ll  n;
    cin >> n;
    cout << quick_squa(n);
    return 0;
}