Submission #203478

#	Time	Username	Problem	Language	Result	Execution time	Memory
203478		stefdasca	Rectangles (IOI19_rect)	C++14	72 / 100	5107 ms	715300 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
    {
        int maxst[2502][2502], maxdr[2502][2502], maxup[2502][2502], maxdwn[2502][2502];
        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[2502][15][2502];
        int rmq2[2502][15][2502];
        int Logg[2502] = {0};
        for(int i = 2; i <= 2500; ++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 && j+1 < m)
                        {
                            int mx2 = max(rmq[j+1][lg][borderup + 1], rmq[j+1][lg][(borderdown - 1) - (1<<lg) + 1]);
                            if(mx2 <= i)
                                ++ans;
                        }
                    }
                }
            }
    }
	return ans;
}

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