結果

問題 No.2328 Build Walls
ユーザー 👑 NachiaNachia
提出日時 2023-05-28 15:17:35
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 384 ms / 3,000 ms
コード長 10,033 bytes
コンパイル時間 1,236 ms
コンパイル使用メモリ 104,804 KB
最終ジャッジ日時 2025-02-13 12:55:07
ジャッジサーバーID
(参考情報)
judge1 / judge2
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 3
other AC * 34
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#line 1 "..\\Main.cpp"
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <atcoder/modint>
#line 3 "D:\\Programming\\VSCode\\competitive-cpp\\nachia\\graph\\graph.hpp"
#include <utility>
#include <cassert>
#line 5 "D:\\Programming\\VSCode\\competitive-cpp\\nachia\\array\\csr-array.hpp"
namespace nachia{
template<class Elem>
class CsrArray{
public:
struct ListRange{
using iterator = typename std::vector<Elem>::iterator;
iterator begi, endi;
iterator begin() const { return begi; }
iterator end() const { return endi; }
int size() const { return (int)std::distance(begi, endi); }
Elem& operator[](int i) const { return begi[i]; }
};
struct ConstListRange{
using iterator = typename std::vector<Elem>::const_iterator;
iterator begi, endi;
iterator begin() const { return begi; }
iterator end() const { return endi; }
int size() const { return (int)std::distance(begi, endi); }
const Elem& operator[](int i) const { return begi[i]; }
};
private:
int m_n;
std::vector<Elem> m_list;
std::vector<int> m_pos;
public:
CsrArray() : m_n(0), m_list(), m_pos() {}
static CsrArray Construct(int n, std::vector<std::pair<int, Elem>> items){
CsrArray res;
res.m_n = n;
std::vector<int> buf(n+1, 0);
for(auto& [u,v] : items){ ++buf[u]; }
for(int i=1; i<=n; i++) buf[i] += buf[i-1];
res.m_list.resize(buf[n]);
for(int i=(int)items.size()-1; i>=0; i--){
res.m_list[--buf[items[i].first]] = std::move(items[i].second);
}
res.m_pos = std::move(buf);
return res;
}
static CsrArray FromRaw(std::vector<Elem> list, std::vector<int> pos){
CsrArray res;
res.m_n = pos.size() - 1;
res.m_list = std::move(list);
res.m_pos = std::move(pos);
return res;
}
ListRange operator[](int u) { return ListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; }
ConstListRange operator[](int u) const { return ConstListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; }
int size() const { return m_n; }
int fullSize() const { return (int)m_list.size(); }
};
} // namespace nachia
#line 6 "D:\\Programming\\VSCode\\competitive-cpp\\nachia\\graph\\graph.hpp"
namespace nachia{
struct Graph {
public:
struct Edge{
int from, to;
void reverse(){ std::swap(from, to); }
};
using Base = std::vector<std::pair<int, int>>;
Graph(int n = 0, bool undirected = false, int m = 0) : m_n(n), m_e(m), m_isUndir(undirected) {}
Graph(int n, const std::vector<std::pair<int, int>>& edges, bool undirected = false) : m_n(n), m_isUndir(undirected){
m_e.resize(edges.size());
for(std::size_t i=0; i<edges.size(); i++) m_e[i] = { edges[i].first, edges[i].second };
}
template<class Cin>
static Graph Input(Cin& cin, int n, bool undirected, int m, bool offset = 0){
Graph res(n, undirected, m);
for(int i=0; i<m; i++){
int u, v; cin >> u >> v;
res[i].from = u - offset;
res[i].to = v - offset;
}
return res;
}
int numVertices() const noexcept { return m_n; }
int numEdges() const noexcept { return int(m_e.size()); }
int addNode() noexcept { return m_n++; }
int addEdge(int from, int to){ m_e.push_back({ from, to }); return numEdges() - 1; }
Edge& operator[](int ei) noexcept { return m_e[ei]; }
const Edge& operator[](int ei) const noexcept { return m_e[ei]; }
Edge& at(int ei) { return m_e.at(ei); }
const Edge& at(int ei) const { return m_e.at(ei); }
auto begin(){ return m_e.begin(); }
auto end(){ return m_e.end(); }
auto begin() const { return m_e.begin(); }
auto end() const { return m_e.end(); }
bool isUndirected() const noexcept { return m_isUndir; }
void reverseEdges() noexcept { for(auto& e : m_e) e.reverse(); }
void contract(int newV, const std::vector<int>& mapping){
assert(numVertices() == int(mapping.size()));
for(int i=0; i<numVertices(); i++) assert(0 <= mapping[i] && mapping[i] < newV);
for(auto& e : m_e){ e.from = mapping[e.from]; e.to = mapping[e.to]; }
m_n = newV;
}
std::vector<Graph> induce(int num, const std::vector<int>& mapping) const {
int n = numVertices();
assert(n == int(mapping.size()));
for(int i=0; i<n; i++) assert(-1 <= mapping[i] && mapping[i] < num);
std::vector<int> indexV(n), newV(num);
for(int i=0; i<n; i++) if(mapping[i] >= 0) indexV[i] = newV[mapping[i]]++;
std::vector<Graph> res; res.reserve(num);
for(int i=0; i<num; i++) res.emplace_back(newV[i], isUndirected());
for(auto e : m_e) if(mapping[e.from] == mapping[e.to] && mapping[e.to] >= 0) res[mapping[e.to]].addEdge(indexV[e.from], indexV[e.to]);
return res;
}
CsrArray<int> getEdgeIndexArray(bool undirected) const {
std::vector<std::pair<int, int>> src;
src.reserve(numEdges() * (undirected ? 2 : 1));
for(int i=0; i<numEdges(); i++){
auto e = operator[](i);
src.emplace_back(e.from, i);
if(undirected) src.emplace_back(e.to, i);
}
return CsrArray<int>::Construct(numVertices(), src);
}
CsrArray<int> getEdgeIndexArray() const { return getEdgeIndexArray(isUndirected()); }
CsrArray<int> getAdjacencyArray(bool undirected) const {
std::vector<std::pair<int, int>> src;
src.reserve(numEdges() * (undirected ? 2 : 1));
for(auto e : m_e){
src.emplace_back(e.from, e.to);
if(undirected) src.emplace_back(e.to, e.from);
}
return CsrArray<int>::Construct(numVertices(), src);
}
CsrArray<int> getAdjacencyArray() const { return getAdjacencyArray(isUndirected()); }
private:
int m_n;
std::vector<Edge> m_e;
bool m_isUndir;
};
} // namespace nachia
#line 4 "D:\\Programming\\VSCode\\competitive-cpp\\nachia\\graph\\dijkstra.hpp"
#include <queue>
namespace nachia{
// require :
// Weight + Weight
// Weight < Weight
// constructor Weight(Weight2)
template<class Weight = long long, class Weight2 = Weight>
struct DijkstraShortestPath {
private:
nachia::Graph g;
std::vector<Weight> dist;
std::vector<int> pre;
std::vector<int> ord;
public:
DijkstraShortestPath(
nachia::Graph graph,
const std::vector<Weight2>& weight,
const std::vector<std::pair<int, Weight>>& starting,
const Weight Inf,
int goal = -1
){
using T = std::pair<Weight, int>;
g = std::move(graph);
auto adj = g.getEdgeIndexArray();
std::vector<Weight> D(g.numVertices(), Inf);
std::vector<int> E(g.numVertices(), -1);
struct Comp { bool operator()(T a, T b) const noexcept { return b < a; }; };
std::priority_queue<T, std::vector<T>, Comp> Q;
ord.clear();
for(auto a : starting) if(a.second < D[a.first]){
D[a.first] = a.second;
Q.push({ a.second, a.first });
}
while(Q.size()){
int p = Q.top().second;
Weight d = Q.top().first; Q.pop();
if(D[p] < d) continue;
ord.push_back(p);
if(p == goal) break;
for(auto e : adj[p]){
int q = g[e].from ^ g[e].to ^ p;
Weight nxd = d + Weight(weight[e]);
if(!(nxd < D[q])) continue;
E[q] = e;
D[q] = nxd;
Q.emplace(nxd, q);
}
}
dist = std::move(D);
pre = std::move(E);
}
Weight distTo(int v) const noexcept { return dist[v]; }
int prevEdge(int v) const noexcept { return pre[v]; }
int prevVertex(int v) const noexcept { return pre[v] >= 0 ? g[pre[v]].from ^ g[pre[v]].to ^ v : -1; }
std::vector<int> pathTo(int v) const {
std::vector<int> res;
while(pre[v] >= 0){
res.push_back(pre[v]);
v = prevVertex(v);
}
std::reverse(res.begin(), res.end());
return res;
}
std::vector<int> getSearchOrder() const { return ord; }
Graph getTree() const {
Graph res(g.numVertices(), false);
for(int i=0; i<g.numVertices(); i++) if(pre[i] >= 0){
res.addEdge(prevVertex(i), i);
}
return res;
}
};
} // namespace nachia
#line 7 "..\\Main.cpp"
using namespace std;
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(int i=0; i<(int)(n); i++)
const i64 INF = 1001001001001001001;
using Modint = atcoder::static_modint<998244353>;
int main(){
int H, W; cin >> H >> W; H -= 2;
vector<vector<i64>> A(H, vector<i64>(W+2));
rep(y,H) rep(x,W) cin >> A[y][x+1];
W+=2;
rep(y,H) rep(x,W) if(A[y][x] < 0) A[y][x] = INF;
vector<i64> X;
nachia::Graph graph(H*W);
rep(y,H) rep(x,W){
if(x){
graph.addEdge(y*W+x, y*W+x-1); X.push_back(A[y][x-1]);
graph.addEdge(y*W+x-1, y*W+x); X.push_back(A[y][x]);
}
if(y){
graph.addEdge(y*W+x, y*W+x-W); X.push_back(A[y-1][x]);
graph.addEdge(y*W+x-W, y*W+x); X.push_back(A[y][x]);
}
if(x && y){
graph.addEdge(y*W+x-1, y*W+x-W); X.push_back(A[y-1][x]);
graph.addEdge(y*W+x-W, y*W+x-1); X.push_back(A[y][x-1]);
graph.addEdge(y*W+x, y*W+x-W-1); X.push_back(A[y-1][x-1]);
graph.addEdge(y*W+x-W-1, y*W+x); X.push_back(A[y][x]);
}
}
auto path = nachia::DijkstraShortestPath<i64>(graph, X, {{0,0}}, INF);
i64 ans = path.distTo(H*W-1);
if(ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
struct ios_do_not_sync{
ios_do_not_sync(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
} ios_do_not_sync_instance;
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0