89 lines
2.5 KiB
C++
89 lines
2.5 KiB
C++
#include <string>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <iostream>
|
|
|
|
struct Info {
|
|
int cnt[26]{};
|
|
bool has_value = false;
|
|
bool is_bad = false;
|
|
bool in_loop = false;
|
|
|
|
Info& operator&=(const Info& rhs) {
|
|
for (int i = 0; i < 26; ++i)
|
|
this->cnt[i] = std::max(this->cnt[i], rhs.cnt[i]);
|
|
return *this;
|
|
}
|
|
|
|
int get() const {
|
|
int ret = cnt[0];
|
|
for (int i = 1; i < 26; ++i)
|
|
ret = std::max(ret, cnt[i]);
|
|
return ret;
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* 1857. Largest Color Value in a Directed Graph
|
|
*
|
|
* There is a directed graph of n colored nodes and m edges. The nodes are numbered from 0 to n - 1.
|
|
* You are given a string colors where colors[i] is a lowercase English letter representing the color of the ith node in this graph (0-indexed). You are also given a 2D array edges where edges[j] = [aj, bj] indicates that there is a directed edge from node aj to node bj.
|
|
* A valid path in the graph is a sequence of nodes x1 -> x2 -> x3 -> ... -> xk such that there is a directed edge from xi to xi+1 for every 1 <= i < k. The color value of the path is the number of nodes that are colored the most frequently occurring color along that path.
|
|
* Return the largest color value of any valid path in the given graph, or -1 if the graph contains a cycle.
|
|
*/
|
|
|
|
class Solution {
|
|
public:
|
|
static int largestPathValue(const std::string&, const std::vector<std::vector<int>>&);
|
|
};
|
|
|
|
int Solution::largestPathValue(const std::string& colors, const std::vector<std::vector<int>>& edges) {
|
|
const int m = edges.size(), n = colors.length();
|
|
std::vector<std::vector<int>> G(n);
|
|
for (auto&& e : edges)
|
|
G[e[0]].push_back(e[1]);
|
|
std::vector<Info> dp(n);
|
|
std::function<const Info&(int)> d = [&](int idx) -> const Info& {
|
|
auto& ans = dp[idx];
|
|
if (ans.has_value)
|
|
return ans;
|
|
if (ans.in_loop) {
|
|
ans.is_bad = true;
|
|
return ans;
|
|
} else if (G[idx].empty()) {
|
|
ans.cnt[colors[idx] - 'a'] = 1;
|
|
ans.has_value = true;
|
|
return ans;
|
|
}
|
|
ans.in_loop = true;
|
|
for (int nx : G[idx]) {
|
|
const auto& nxd = d(nx);
|
|
if (nxd.is_bad) {
|
|
ans.is_bad = true;
|
|
return ans;
|
|
}
|
|
ans &= nxd;
|
|
}
|
|
++ans.cnt[colors[idx] - 'a'];
|
|
ans.has_value = true;
|
|
ans.in_loop = false;
|
|
return ans;
|
|
};
|
|
int ans = -1;
|
|
for (int i = 0; i < n; ++i) {
|
|
const auto& c = d(i);
|
|
if (c.is_bad)
|
|
return -1;
|
|
ans = std::max(ans, c.get());
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
int main() {
|
|
std::cout << Solution::largestPathValue("hhqhuqhqff", {
|
|
{0,1},{0,2},{2,3},{3,4},{3,5},{5,6},{2,7},{6,7},{7,8},{3,8},{5,8},{8,9},{3,9},{6,9}
|
|
});
|
|
return 0;
|
|
}
|