Table of Contents
Jumping Rooks – HackerRank Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.
Solutions of Algorithms Data Structures Hard HackerRank:
Here are all the Solutions of Hard , Advanced , Expert Algorithms of Data Structure of Hacker Rank , Leave a comment for similar posts
C++ Jumping Rooks HackerRank Solution
#include <iostream>
#include <vector>
#include <cmath>
#include <ctime>
#include <cassert>
#include <cstdio>
#include <queue>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <algorithm>
#include <numeric>
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef long long i64;
typedef vector<i64> vi64;
typedef vector<vi64> vvi64;
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
const int MAXN = 100000, MAXM = 1000000;
const int INF = 1e8;
struct TEdge {
int from, to;
int c, ocost, cost, w;
TEdge(int from = 0, int to = 0, int c = 0, int cost = 0)
: from(from)
, to(to)
, c(c)
, ocost(cost)
, cost(cost)
, w(0)
{
}
};
vi e[MAXN];
TEdge edges[2 * MAXM];
int ec = 0;
void addEdge(int from, int to, int c, int cost) {
if (c <= 0) return;
e[from].pb(ec);
edges[ec++] = TEdge(from, to, c, cost);
e[to].pb(ec);
edges[ec++] = TEdge(to, from, 0, -cost);
}
int dist[MAXN], vis[MAXN], par[MAXN], pushed[MAXN];
int pot[MAXN];
void init(int N) {
forn(i, N) {
dist[i] = INF;
vis[i] = 0;
par[i] = -1;
pushed[i] = 0;
}
}
void reduceCost() {
forn(i, ec) {
if (edges[i].w < edges[i].c) {
edges[i].cost += dist[edges[i].from] - dist[edges[i].to];
edges[i ^ 1].cost = 0;
}
}
}
int push(int from, int to, int N) {
init(N);
dist[from] = 0;
pushed[from] = INF;
set<pii> q;
q.insert(mp(dist[from], from));
while (!q.empty()) {
int m = q.begin()->se;
q.erase(q.begin());
vis[m] = 1;
for (int id: e[m]) {
if (edges[id].w >= edges[id].c) continue;
int to = edges[id].to;
int w = edges[id].cost;
if (dist[m] + w < dist[to]) {
q.erase(mp(dist[to], to));
dist[to] = dist[m] + w;
q.insert(mp(dist[to], to));
par[to] = id;
pushed[to] = min(pushed[m], edges[id].c - edges[id].w);
}
}
}
reduceCost();
if (!pushed[to]) return 0;
int pt = pushed[to];
int v = to;
while (par[v] != -1) {
int id = par[v];
edges[id].w += pt;
edges[id ^ 1].w -= pt;
v = edges[id].from;
}
return pt;
}
void maxflow_mincost(int from, int to, int N, int K) {
init(N);
dist[from] = 0;
bool changed;
do {
changed = false;
forn(i, ec) {
if (edges[i].w >= edges[i].c) continue;
changed |= uin(dist[edges[i].to], dist[edges[i].from] + edges[i].cost);
}
} while (changed);
reduceCost();
// --K;
while (K--) {push(from, to, N);}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
#ifdef LOCAL_DEFINE
freopen("input.txt", "rt", stdin);
#endif
int n, k;
cin >> n >> k;
vector<string> f(n);
forn(i, n) cin >> f[i];
vvi hs(n, vi(n)), vs(n, vi(n));
int H = 0, V = 0;
vi szh, szv;
forn(i, n) forn(j, n) {
if (f[i][j] != '.') continue;
if (!j || f[i][j - 1] == '#') ++H, szh.pb(0);
hs[i][j] = H - 1; ++szh.back();
}
forn(j, n) forn(i, n) {
if (f[i][j] != '.') continue;
if (!i || f[i - 1][j] == '#') ++V, szv.pb(0);
vs[i][j] = V - 1; ++szv.back();
}
int S = 0, T = 1;
int off0 = 2, off1 = off0 + H, N = off1 + V;
forn(j, H) forn(i, szh[j]) addEdge(S, off0 + j, 1, i);
forn(j, V) forn(i, szv[j]) addEdge(off1 + j, T, 1, i);
forn(i, n) forn(j, n) {
if (f[i][j] == '#') continue;
// cerr << i << ' ' << j << ' ' << hs[i][j] << ' ' << vs[i][j] << '\n';
addEdge(off0 + hs[i][j], off1 + vs[i][j], 1, 0);
}
maxflow_mincost(S, T, N, k);
int ans = 0;
forn(i, ec) ans += edges[i].w * edges[i].ocost;
ans /= 2;
cout << ans << '\n';
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
Java Jumping Rooks HackerRank Solution
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
public class C {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni(), K = ni();
char[][] map = nm(n,n);
int[][] ud = new int[n][n];
int[][] lr = new int[n][n];
int pud = 0, plr = 0;
{
int id = -1;
for(int i = 0;i < n;i++){
char pre = 0;
for(int j = 0;j < n;j++){
if(map[j][i] == '.'){
if(pre != '.')id++;
ud[j][i] = id;
}
pre = map[j][i];
}
}
pud = id + 1;
}
{
int id = -1;
for(int i = 0;i < n;i++){
char pre = 0;
for(int j = 0;j < n;j++){
if(map[i][j] == '.'){
if(pre != '.')id++;
lr[i][j] = id;
}
pre = map[i][j];
}
}
plr = id + 1;
}
List<Edge> es = new ArrayList<>();
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
if(map[i][j] == '.'){
es.add(new Edge(ud[i][j], lr[i][j]+pud, 1, 0));
}
}
}
int src = pud + plr, sink = src + 1;
for(int i = 0;i < pud;i++){
for(int j = 0;j <= n;j++){
es.add(new Edge(src, i, 1, j));
}
}
for(int i = 0;i < plr;i++){
for(int j = 0;j <= n;j++){
es.add(new Edge(i+pud, sink, 1, j));
}
}
out.println(solveMinCostFlow(compileWD(sink+1, es), src, sink, K));
}
public static class Edge
{
public int from, to;
public int capacity;
public int cost;
public int flow;
public Edge complement;
// public int iniflow;
public Edge(int from, int to, int capacity, int cost) {
this.from = from;
this.to = to;
this.capacity = capacity;
this.cost = cost;
}
}
public static Edge[][] compileWD(int n, List<Edge> edges)
{
Edge[][] g = new Edge[n][];
// cloning
for(int i = edges.size()-1;i >= 0;i--){
Edge origin = edges.get(i);
Edge clone = new Edge(origin.to, origin.from, origin.capacity, -origin.cost);
clone.flow = origin.capacity;
clone.complement = origin;
origin.complement = clone;
edges.add(clone);
}
int[] p = new int[n];
for(Edge e : edges)p[e.from]++;
for(int i = 0;i < n;i++)g[i] = new Edge[p[i]];
for(Edge e : edges)g[e.from][--p[e.from]] = e;
return g;
}
// NOT VERIFIED
public static Edge[][] compileWU(int n, List<Edge> edges)
{
Edge[][] g = new Edge[n][];
// cloning
for(int i = edges.size()-1;i >= 0;i--){
Edge origin = edges.get(i);
Edge back = new Edge(origin.to, origin.from, origin.capacity, origin.cost);
edges.add(back);
}
for(int i = edges.size()-1;i >= 0;i--){
Edge origin = edges.get(i);
Edge clone = new Edge(origin.to, origin.from, origin.capacity, -origin.cost);
clone.flow = origin.capacity;
clone.complement = origin;
origin.complement = clone;
edges.add(clone);
}
int[] p = new int[n];
for(Edge e : edges)p[e.from]++;
for(int i = 0;i < n;i++)g[i] = new Edge[p[i]];
for(Edge e : edges)g[e.from][--p[e.from]] = e;
return g;
}
public static long solveMinCostFlow(Edge[][] g, int source, int sink, long all)
{
int n = g.length;
long mincost = 0;
int[] potential = new int[n];
final int[] d = new int[n];
MinHeap q = new MinHeap(n);
while(all > 0){
// shortest path src->sink
Edge[] inedge = new Edge[n];
Arrays.fill(d, Integer.MAX_VALUE / 2);
d[source] = 0;
q.add(source, 0);
while(q.size() > 0){
int cur = q.argmin();
q.remove(cur);
for(Edge ne : g[cur]){
if(ne.capacity - ne.flow > 0){
int nd = d[cur] + ne.cost + potential[cur] - potential[ne.to];
if(d[ne.to] > nd){
inedge[ne.to] = ne;
d[ne.to] = nd;
q.update(ne.to, nd);
}
}
}
}
if(inedge[sink] == null)break;
long minflow = all;
long sumcost = 0;
for(Edge e = inedge[sink];e != null;e = inedge[e.from]){
if(e.capacity - e.flow < minflow)minflow = e.capacity - e.flow;
sumcost += e.cost;
}
mincost += minflow * sumcost;
for(Edge e = inedge[sink];e != null;e = inedge[e.from]){
e.flow += minflow;
e.complement.flow -= minflow;
}
all -= minflow;
for(int i = 0;i < n;i++){
potential[i] += d[i];
}
}
return mincost;
}
public static class MinHeap {
public int[] a;
public int[] map;
public int[] imap;
public int n;
public int pos;
public static int INF = Integer.MAX_VALUE;
public MinHeap(int m)
{
n = m+2;
a = new int[n];
map = new int[n];
imap = new int[n];
Arrays.fill(a, INF);
Arrays.fill(map, -1);
Arrays.fill(imap, -1);
pos = 1;
}
public int add(int ind, int x)
{
int ret = imap[ind];
if(imap[ind] < 0){
a[pos] = x; map[pos] = ind; imap[ind] = pos;
pos++;
up(pos-1);
}
return ret != -1 ? a[ret] : x;
}
public int update(int ind, int x)
{
int ret = imap[ind];
if(imap[ind] < 0){
a[pos] = x; map[pos] = ind; imap[ind] = pos;
pos++;
up(pos-1);
}else{
int o = a[ret];
a[ret] = x;
up(ret);
down(ret);
// if(a[ret] > o){
// up(ret);
// }else{
// down(ret);
// }
}
return x;
}
public int remove(int ind)
{
if(pos == 1)return INF;
if(imap[ind] == -1)return INF;
pos--;
int rem = imap[ind];
int ret = a[rem];
map[rem] = map[pos];
imap[map[pos]] = rem;
imap[ind] = -1;
a[rem] = a[pos];
a[pos] = INF;
map[pos] = -1;
up(rem);
down(rem);
return ret;
}
public int min() { return a[1]; }
public int argmin() { return map[1]; }
public int size() { return pos-1; }
private void up(int cur)
{
for(int c = cur, p = c>>>1;p >= 1 && a[p] > a[c];c>>>=1, p>>>=1){
int d = a[p]; a[p] = a[c]; a[c] = d;
int e = imap[map[p]]; imap[map[p]] = imap[map[c]]; imap[map[c]] = e;
e = map[p]; map[p] = map[c]; map[c] = e;
}
}
private void down(int cur)
{
for(int c = cur;2*c < pos;){
int b = a[2*c] < a[2*c+1] ? 2*c : 2*c+1;
if(a[b] < a[c]){
int d = a[c]; a[c] = a[b]; a[b] = d;
int e = imap[map[c]]; imap[map[c]] = imap[map[b]]; imap[map[b]] = e;
e = map[c]; map[c] = map[b]; map[b] = e;
c = b;
}else{
break;
}
}
}
}
void run() throws Exception
{
is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new C().run(); }
private byte[] inbuf = new byte[1024];
private int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static void tr(Object... o) { System.out.println(Arrays.deepToString(o)); }
}
C Jumping Rooks HackerRank Solution
#include<stdio.h>
#include<stdbool.h>
#define maxn 155
#define maxV 24035
#define maxE 96110
bool area[maxn][maxn];
int hnum[maxn][maxn], vnum[maxn][maxn], vdeg[maxn*maxn], hdeg[maxn*maxn], first[maxV], next[maxE], to[maxE], from[maxE], cap[maxE], cost[maxE], ecnt;
void add_edge(int u, int v, int _cap, int _cost)
{
next[ecnt] = first[u];
to[ecnt] = v;
from[ecnt] = u;
cap[ecnt] = _cap;
cost[ecnt] = _cost;
first[u] = ecnt;
ecnt++;
next[ecnt] = first[v];
to[ecnt] = u;
from[ecnt] = v;
cap[ecnt] = 0;
cost[ecnt] = -_cost;
first[v] = ecnt;
ecnt++;
}
bool inq[maxV];
int q[maxV], dist[maxV], h[maxV];
int push_flow(int S, int T)
{
for( int i = 0 ; i <= T ; i++ )
{
inq[i] = 0, dist[i] = (int)1e9, h[i] = -1;
}
int ql = 0, qr = 0;
dist[S] = 0;
h[S] = -1;
q[qr++] = S;
inq[S] = 1;
while( ql != qr )
{
int cur = q[ql];
inq[cur] = 0;
ql++;
if( ql == maxV )
{
ql = 0;
}
for( int i = first[cur] ; i != -1 ; i = next[i] )
{
if( cap[i] > 0 && dist[to[i]] > dist[cur] + cost[i] )
{
dist[to[i]] = dist[cur] + cost[i];
h[to[i]] = i;
if(!inq[to[i]])
{
q[qr] = to[i];
inq[to[i]] = 1;
qr++;
if( qr == maxV )
{
qr = 0;
}
}
}
}
}
if( dist[T] == (int)1e9 )
{
return -1;
}
int cur = T, pcost = 0;
while( h[cur] != -1 )
{
cap[h[cur]]--;
cap[h[cur]^1]++;
pcost += cost[h[cur]];
cur = from[h[cur]];
}
return pcost;
}
int main()
{
int n, k;
scanf("%d%d", &n, &k);
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
char u[3];
scanf("%1s", u);
if( u[0] == '#' )
{
area[i][j] = 0;
}
else
{
area[i][j] = 1;
}
}
}
int hcnt = 0, vcnt = 0;
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
if(area[i][j])
{
if( j == 0 || !area[i][j-1] )
{
hnum[i][j] = hcnt++;
}
else
{
hnum[i][j] = hnum[i][j-1];
}
}
}
}
for( int j = 0 ; j < n ; j++ )
{
for( int i = 0 ; i < n ; i++ )
{
if(area[i][j])
{
if( i == 0 || !area[i-1][j] )
{
vnum[i][j] = vcnt++;
}
else
{
vnum[i][j] = vnum[i-1][j];
}
}
}
}
int S = hcnt + vcnt, T = hcnt + vcnt + 1;
ecnt = 0;
for( int i = 0 ; i < hcnt ; i++ )
{
hdeg[i] = 0;
}
for( int i = 0 ; i < vcnt ; i++ )
{
vdeg[i] = 0;
}
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
if(area[i][j])
{
hdeg[hnum[i][j]]++, vdeg[vnum[i][j]]++;
}
}
}
for( int i = 0 ; i <= T ; i++ )
{
first[i] = -1;
}
for( int i = 0 ; i < hcnt ; i++ )
{
for( int j = 0 ; j < hdeg[i] ; j++ )
{
add_edge(S, i, 1, j);
}
}
for( int i = 0 ; i < vcnt ; i++ )
{
for( int j = 0 ; j < vdeg[i] ; j++ )
{
add_edge(i+hcnt, T, 1, j);
}
}
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
if(area[i][j])
{
add_edge(hnum[i][j], vnum[i][j] + hcnt, 1, 0);
}
}
}
int res = 0;
for( int i = 0 ; i < k ; i++ )
{
int z = push_flow(S, T);
res += z;
}
printf("%d", res);
return 0;
}
Leave a comment below
