Submission #203474

#	Time	Username	Problem	Language	Result	Execution time	Memory
203474		stefdasca	Rectangles (IOI19_rect)	C++14	13 / 100	606 ms	79096 KiB

rect

#include "rect.h"
#include<bits/stdc++.h>
using namespace std;
long long count_rectangles(vector<vector<int> > a)
{
    int n = a.size();
    int m = a[0].size();
    int max_val = 0;
    int min_val = (1<<30);
	for(int i = 0; i < n; ++i)
        for(int j = 0; j < m; ++j)
        {
            max_val = max(max_val, a[i][j]);
            min_val = min(min_val, a[i][j]);
        }
    if(max_val == min_val)
        return 0;
    long long ans = 0;
    if(max_val == 1)
    {
        vector<vector<int> >viz(n, vector<int>(m));
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < m; ++j)
                viz[i][j] = 0;
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < m; ++j)
            {
                if(a[i][j] == 0 && !viz[i][j])
                {
                    int minix = i, maxix = i, miniy = j, maxiy = j;
                    int cnt = 1;
                    viz[i][j] = 1;
                    deque<pair<int, int> >d;
                    d.push_back({i, j});
                    while(!d.empty())
                    {
                        pair<int, int> nod = d[0];
                        d.pop_front();
                        for(int ox = -1; ox <= 1; ++ox)
                            for(int oy = -1; oy <= 1; ++oy)
                            {
                                if(ox && oy)
                                    continue;
                                if(!ox && !oy)
                                    continue;
                                int new_x = nod.first + ox;
                                int new_y = nod.second + oy;
                                if(new_x >= 0 && new_y >= 0 && new_x < n && new_y < m)
                                {
                                    if(a[new_x][new_y] == 0 && !viz[new_x][new_y])
                                    {
                                        viz[new_x][new_y] = 1;
                                        d.push_back({new_x, new_y});
                                        minix = min(minix, new_x);
                                        maxix = max(maxix, new_x);
                                        miniy = min(miniy, new_y);
                                        maxiy = max(maxiy, new_y);
                                        ++cnt;
                                    }
                                }
                            }
                    }
                    if(minix && miniy && maxix < n-1 && maxiy < m-1)
                    {
                        if(cnt == (maxix - minix + 1) * (maxiy - miniy + 1))
                            ++ans;
                    }
                }
            }
    }
    else
        if(n <= 700)
        {
            int maxst[702][702], maxdr[702][702], maxup[702][702], maxdwn[702][702];
            deque<int> d;
            for(int i = 0; i < n; ++i)
            {
                for(int j = 0; j < m; ++j)
                {
                    while(!d.empty() && a[i][j] > a[i][d.back()])
                        d.pop_back();
                    if(d.empty())
                        maxst[i][j] = -1;
                    else
                        maxst[i][j] = d.back();
                    d.push_back(j);
                }
                d.clear();
                for(int j = m - 1; j >= 0; --j)
                {
                    while(!d.empty() && a[i][j] > a[i][d.back()])
                        d.pop_back();
                    if(d.empty())
                        maxdr[i][j] = m;
                    else
                        maxdr[i][j] = d.back();
                    d.push_back(j);
                }
                d.clear();
            }
            for(int i = 0; i < m; ++i)
            {
                for(int j = 0; j < n; ++j)
                {
                    while(!d.empty() && a[j][i] > a[d.back()][i])
                        d.pop_back();
                    if(d.empty())
                        maxup[j][i] = -1;
                    else
                        maxup[j][i] = d.back();
                    d.push_back(j);
                }
                d.clear();
                for(int j = n-1; j >= 0; --j)
                {
                    while(!d.empty() && a[j][i] > a[d.back()][i])
                        d.pop_back();
                    if(d.empty())
                        maxdwn[j][i] = n;
                    else
                        maxdwn[j][i] = d.back();
                    d.push_back(j);
                }
                d.clear();
            }
            int rmq[702][12][702];
            int rmq2[702][12][702];
            int Logg[702] = {0};
            for(int i = 2; i <= 700; ++i)
                Logg[i] = Logg[i/2] + 1;
            for(int i = 0; i < m; ++i)
            {
                for(int j = 0; j < n; ++j)
                    rmq[i][0][j] = maxst[j][i];
                for(int stp = 1; (1<<stp) <= n; ++stp)
                    for(int j = 0; j + (1<<stp) - 1 < n; ++j)
                        rmq[i][stp][j] = max(rmq[i][stp-1][j], rmq[i][stp-1][j + (1<<(stp - 1))]);

                for(int j = 0; j < n; ++j)
                    rmq2[i][0][j] = maxdr[j][i];
                for(int stp = 1; (1<<stp) <= n; ++stp)
                    for(int j = 0; j + (1<<stp) - 1 < n; ++j)
                        rmq2[i][stp][j] = min(rmq2[i][stp-1][j], rmq2[i][stp-1][j + (1<<(stp - 1))]);
            }
            for(int borderup = 0; borderup < n; ++borderup)
                for(int borderdown = borderup + 2; borderdown < n; ++borderdown)
                {
                    for(int i = 0; i + 2 < m; ++i)
                    {
                        int lg = Logg[borderdown - borderup - 1];
                        int mx = min(rmq2[i][lg][borderup + 1], rmq2[i][lg][(borderdown - 1) - (1<<lg) + 1]);
                        bool ok = 1;
                        for(int j = i+1; j < mx && ok; ++j)
                        {
                            ok &= (maxdwn[borderup][j] >= borderdown && maxup[borderdown][j] <= borderup);
                            if(ok)
                            {
                                int mx2 = max(rmq[j+1][lg][borderup + 1], rmq[j+1][lg][(borderdown - 1) - (1<<lg) + 1]);
                                if(mx2 <= i)
                                    ++ans;
                            }
                        }
                    }
                }
        }
	return ans;
}

Compilation message (stderr)

rect.cpp: In function 'long long int count_rectangles(std::vector<std::vector<int> >)':
rect.cpp:71:5: warning: this 'else' clause does not guard... [-Wmisleading-indentation]
     else
     ^~~~
rect.cpp:166:2: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'else'
  return ans;
  ^~~~~~

• Subtask 1: 0 / 8
• Subtask 2: 0 / 7
• Subtask 3: 0 / 12
• Subtask 4: 0 / 22
• Subtask 5: 0 / 10
• Subtask 6: 13 / 13
• Subtask 7: 0 / 28