No editorial for me for problem F this time, but solutions to A-E and my commentary are available here for people who are interested!

0-1 bfs is very useful here!

Can you please help me understanding the 2nd test case of D problem, I mean why the magician can't go at (3,1) using his 1 magic spell and then move downward at (4,1)? Or It is compulsory to use move-A first and then move-B?

why we add to beginning of queue if it is reachable by current node without magic otherwise at last?

beautifully written code nmnsharma007

can u explain a bit please?

it took me approx 25 minutes to write the code.

well, I read dreamoon's code. It's a dp problem...

hoW can you explain a bit??

Same logic , maps TLED my solution!

Thank You for the great explanation. Made things up clear.

include<stdio.h>

int main() { long long a,b,c,d,e,f,g,h,i,j,k,l; scanf("%lli",&a,&b,&c); int z[a][b]; for(d=0;d<a;d++) { for(e=0;e<b;e++)z[d][e]=0; } for(;c;c--) { scanf("%lli%lli",&d,&e); z[d-1][e-1]=1; } long long y[a],x[b]; for(d=0;d<a;d++) { for(e=f=0;e<b;e++) { if(z[d][e])f++; } y[d]=f; } for(d=0;d<b;d++) { for(e=f=0;e<a;e++) { if(z[e][d])f++; } x[d]=f; } for(d=f=0;d<a;d++) { for(e=0;e<b;e++) { g=y[d]+x[e]; if(z[d][e])g--; if(g>f)f=g; } } printf("%lli\n",f); return 0; }

I wrote this for E. But I got error : warning: ignoring return value of ‘scanf’, declared with attribute warn_unused_result [-Wunused-result]

What is the reason for that? Only some test sets return this error, rest give AC. Do you have any suggestion?

https://atcoder.jp/contests/abc176/submissions/16135523 Submission link. Sorry for the wrong formatting

if size of first vector * size of second vector > 300000 then output maximum number of bombs in a row + maximum number of bombs in a column.if size <300000 then how can we be sure that ans is maximum number of bombs in a row + maximum number of bombs?

What's the idea behind it? I did exactly same as Dorost

I did the same approach

3 3 5
1 1
1 2
2 1
2 3
3 2

I really can't believe problemsetters made 130 tests and couldn't defeat this solution

#include<bits/stdc++.h>
#define ll long long
#define fo(i,n) for(int i=0;i<n;i++)
#define rfo(i,n) for(int i=n-1;i>=0;i--)
#define Fo(i,q,n) for(int i=q;i<n;i++)
#define rFo(i,q,n) for(int i=n-1;i>=q;i--)
#define fO(i,n,k) for(int i=0;i<n;i+=k)
#define FO(i,q,n,k) for(int i=q;i<n;i+=k)
#define zero(a,n) memset(a,0,sizeof(a[0])*n)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define endl "\n"
#define Endl "\n"
#define trace(x) cerr<<#x<<": "<<x<<" "<<endl;
using namespace std;
const int MOD=1000000007;
void print(){cout <<endl;}
template <typename T, typename... Types> 
void print(T var1, Types... var2){cout << var1 << " " ;print(var2...) ;}
//ceil of a/b
template <typename T>
T fceil(T a,T b){return (T)(a+b-1)/b;}
//const int N=2e5;
//int arr[N+1];
 
 
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int h,w,m;
	cin>>h>>w>>m;
	vector<int> rows(h,0);
	vector<int> cols(w,0);
	int x,y;
	map< pair<int,int> ,int>dict;
	fo(i,m){
		cin>>x>>y;
		x--;y--;
		rows[x]+=1;
		cols[y]+=1;
		dict[mp(x,y)]=1;	
	}
	vector< pair<int,int> > rc;
	fo(i,h){
		rc.pb(mp(rows[i],i));	
	}
	vector< pair<int,int> > cc;
	fo(i,w){
		cc.pb(mp(cols[i],i));
	}
	sort(rc.rbegin(),rc.rend());
	sort(cc.rbegin(),cc.rend());
	vector< pair<int,int> > rcp;
	vector< pair<int,int> > ccp;
	int rmax = rc[0].F;
	int cmax = cc[0].F;
	int k=0;
	while(k<(int)rc.size() && rc[k].F==rmax){
		rcp.pb(rc[k]);
		k++;	
	}
	k=0;
	while(k<(int)cc.size() && cc[k].F==cmax){
		ccp.pb(cc[k]);
		k++;	
	}
	int flag=1;
	fo(i,(int)rcp.size()){
		fo(j,(int)ccp.size()){
			if(dict[mp(rcp[i].S,ccp[j].S)]==0){
				flag=0;
				break;	
			}
		}	
	}
	cout<<rmax+cmax-flag<<endl;
	return 0;
}

Understood.Thanks a lot.

I did the same thing I think, then why tle for 3 cases?

#include<bits/stdc++.h>
using namespace std;
#define ll                          long long
#define in(a)                       ll a; cin>>a;
#define in2(a,b)                    ll a,b; cin>>a>>b;
#define in3(a,b,c)                  ll a,b,c; cin>>a>>b>>c;
#define in4(a,b,c,d)                ll a,b,c,d; cin>>a>>b>>c>>d;
#define in5(a,b,c,d,e)              ll a,b,c,d,e; cin>>a>>b>>c>>d>>e;
#define lelo(b)                     for(auto &i:b)cin>>i;
#define ff                          first
#define ss                          second
#define call(v)                     v.begin(),v.end()
#define rall(v)                     v.rbegin(),v.rend()
#define show(x)                     for(auto t:x)cout<<t<<" ";
#define pb                          push_back
#define bhar(s,v)                   memset(s,v,sizeof(s))
#define endl                        "\n"                       
#define ce(x)                       cout<<x<<"\n";
#define nl                          cout<<endl;
#define jaldi                       ios_base::sync_with_stdio(false);cin.tie(NULL);
#define dekh_lo                     ce("dekh_lo");
#define sz(x)                       (ll)x.size()
#define re                          return

typedef pair<ll,ll> pii;
typedef vector<pii> vii;
typedef vector<ll> vi;

const ll mod=1e9+7;
const ll N=4e5+5;

void solve(){
    in3(h,w,m);

    ll s=m;
    vii cor;
    while(s--){
        in2(x,y);
        cor.pb({x,y});
    }

    vi row(h+1,0),col(w+1,0);
    map<pii,bool> hash;

    for(ll i=0;i<sz(cor);i++){
        row[cor[i].ff]++;
        col[cor[i].ss]++;
        hash[{cor[i].ff,cor[i].ss}]=1;
    }

    ll maxi1=-1e9;
    vi ind1;
    for(ll i=1;i<=h;i++){
        if(row[i]>maxi1){
            maxi1=row[i];
        }
    }

    for(ll i=1;i<=h;i++){
        if(row[i]==maxi1){
            ind1.pb(i);
        }
    }

    ll maxi2=-1e9;
    vi ind2;
    for(ll i=1;i<=w;i++){
        if(col[i]>maxi2){
            maxi2=col[i];
        }
    }

    for(ll i=1;i<=w;i++){
        if(col[i]==maxi2){
            ind2.pb(i);
        }
    }

    bool f=0;
    for(auto j:ind1){
        for(auto i:ind2){
            if(!hash[{j,i}]){
                f=1;
            }
        }   
    }
   

    ll ans=maxi1+maxi2-(f==0);
    ce(ans);
   
}

int32_t main(){
    // jaldi
    ll t; 
    // cin>>t;
    t=1;     
    while(t--){
        solve();
    }
} 

0-1 bfs passed easily.

Your solution isn't handling updates. Like let's say you can go to node $$$x$$$ from node $$$y$$$ in $$$3$$$ sec but from node $$$z$$$ to node $$$y$$$ in $$$2$$$ sec. And you processed node $$$x$$$ before node $$$z$$$. Then, you are not updating with $$$z$$$ and that produces WA.
To handle updates efficiently, we use dijkastra algorithm.
dijkastra
All you have to do is doing the same thing you did, just applying dijkastra instead of dfs

It's better to give a dijkastra problem with little insight in E instead. They can give same difficulty level binary search or greedy problem where you need to think before applying binary search. Even div3 problems consider having some insights. Otherwise, it's like saying, implement dijkastra algorithm.
And yeah, you could have still learnt dijkastra if they put a problem on this algo with a little insight.

It's a lot of implementation anyway. They can give this kind of problems in unrated contests like educational dp contest.