PTA-图的操作

背景知识

深度优先搜索与 DFS 序

深度优先搜索算法（DFS）是一种用于遍历或搜索树或图的算法。以下伪代码描述了在树 T 上进行深度优先搜索的过程：

procedure DFS(T, u, L)      // T 是被深度优先搜索的树
                            // u 是当前搜索的节点
                            // L 是一个链表，保存了所有节点被第一次访问的顺序
  append u to L             // 将节点 u 添加到链表 L 的末尾
  for v in u.children do    // 枚举节点 u 的所有子节点 v
    DFS(T, v)               // 递归搜索节点 v

令 r 为树 T 的根，调用 DFS(T, r, L) 即可完成对 T 的深度优先搜索，保存在链表 L 中的排列被称为 DFS 序。相信聪明的你已经发现了，如果枚举子节点的顺序不同，最终得到的 DFS 序也会不同。

逆序对

给定一个长度为 n 的整数序列 a1​,a2​,⋯,an​，该序列的逆序对数量是同时满足以下条件的有序数对 (i,j) 的数量：

• 1≤i
• ai​>aj​。

问题求解

给定一棵 n 个节点的树，其中节点 r 为根。求该树所有可能的 DFS 序中逆序对数量之和。

输入格式

第一行输入两个整数 n，r（2≤n≤3×105，1≤r≤n）表示树的大小与根节点。

对于接下来的 (n−1) 行，第 i 行输入两个整数 ui​ 与 vi​（1≤ui​,vi​≤n），表示树上有一条边连接节点 ui​ 与 vi​。

输出格式

输出一行一个整数，表示该树所有可能的 DFS 序中逆序对数量之和。由于答案可能很大，请对 109+7 取模后输出。

样例输入 1

5 3
1 5
2 5
3 5
4 3

样例输出 1

24

样例输入 2

10 5
10 2
2 5
10 7
7 1
7 9
4 2
3 10
10 8
3 6

样例输出 2

516

样例解释

下图展示了样例 1 中的树。

该树共有 4 种可能的 DFS 序：

• {3,4,5,1,2}，有 6 个逆序对；
• {3,4,5,2,1}，有 7 个逆序对；
• {3,5,1,2,4}，有 5 个逆序对；
• {3,5,2,1,4}，有 6 个逆序对。

因此答案为 6+7+5+6=24。

代码长度限制16 KB

时间限制        1000 ms

内存限制        256 MB

#include 
#define ll long long
#define mod 1000000007
using namespace std;

const int N = 3e5 + 10;

int n, root;
vector g[N];
ll fact[N], dp[N], mx[N], d[N], deg[N], c[N];

ll qmi(ll a, ll b, ll p)
{
    ll res = 1;
    a %= p;
    while (b)
    {
        if (b & 1)
            res = res * a % p;
        b >>= 1;
        a = a * a % p;
    }
    return res;
}

int lowbit(int x)
{
    return x & (-x);
}

void add(int x, int val)
{
    for (int i = x; i <= n; i += lowbit(i))
        c[i] += val;
}

ll query(int x)
{
    ll res = 0;
    for (int i = x; i; i -= lowbit(i))
        res += c[i];
    return res;
}

void dfs(int u, int fa)
{
    mx[u] = query(n) - query(u);
    add(u, 1);
    dp[u] = 1;
    for (auto &x : g[u])
        if (x != fa)
        {
            deg[u]++;
            dfs(x, u);
            dp[u] = dp[u] * dp[x] % mod;
            d[u] += d[x];
        }
    d[u] += deg[u];
    dp[u] = dp[u] * fact[deg[u]] % mod;
    add(u, -1);
}

ll cal(ll x)
{
    return x * (x - 1) % mod * qmi(2, mod - 2, mod) % mod;
}

void solve()
{
    scanf("%d%d", &n, &root);
    for (int i = 1; i < n; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    fact[0] = 1;
    for (ll i = 1; i <= n; i++)
        fact[i] = fact[i - 1] * i % mod;

    dfs(root, 0);
    ll tmp = cal(n);
    for (int i = 1; i <= n; i++)
        tmp -= d[i], tmp %= mod;
    // cout << tmp << 'n';
    ll res = tmp * qmi(2, mod - 2, mod) % mod;
    for (int i = 1; i <= n; i++)
        res += mx[i], res %= mod;
    res = res * dp[root] % mod;
    cout << (res + mod) % mod;
}

int main()
{
    int i = 1;

    while (i--)
    {
        solve();
    }
    return 0;
}

图的创建

请编写程序创建一个有向图。有向图中包含n个顶点，编号为0至n-1。

输入格式:

输入第一行为两个正整数n和e，分别表示图的顶点数和边数，其中n不超过20000，e不超过20000。接下来e行表示每条边的信息，每行为3个非负整数a、b、c，其中a和b表示该边的端点编号，c表示权值。各边并非按端点编号顺序排列。

输出格式:

按顶点编号递增顺序输出每个顶点引出的边，每个顶点占一行，若某顶点没有引出边，则不输出。每行表示一个顶点引出的所有边，格式为a:(a,b,w)……，表示有向边a->b的权值为w，a引出的多条边按编号b的递增序排列。

输入样例:

7 7
0 1 5
0 3 7
0 6 6
1 2 4
2 5 1
3 5 3
6 5 4

输出样例:

0:(0,1,5)(0,3,7)(0,6,6)
1:(1,2,4)
2:(2,5,1)
3:(3,5,3)
6:(6,5,4)

代码长度限制        16 KB

时间限制                500 ms

内存限制                20 MB

#include
using namespace std;

struct node
{
	int from;
	int to;
	int weight;
};
node noder[20005];
int counts[20005];

bool cmp(node a, node b)
{
	if (a.from != b.from)
		return a.from < b.from;
	return a.to < b.to;
}



int main()
{
	int n, m;
	cin >> n >> m;

	for (int i = 0; i < m; ++i)
	{
		cin >> noder[i].from >> noder[i].to >> noder[i].weight;
		counts[noder[i].from]++;
	}

	sort(noder, noder + m, cmp);
	// 打印
	int cnt = 0;
	for(int i=0;i