[JLOI2016]方[题解]
Posted 未央境
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[JLOI2016]方[题解]相关的知识，希望对你有一定的参考价值。
方
题目大意
给出一个 \\(n\\) 行 \\(m\\) 列的矩阵，每行的格点从上到下依次编号为 \\(0\\) 到 \\(n\\) ，每列的格点从左到右依次编号为 \\(0\\) 到 \\(m\\) 。
选出四个不同的格点，可以组成一个四边形，问有多少种不同的选法，能够组成一个正方形。
由于出题人太害怕你做出这道题，于是他从这个矩阵中删去了 \\(k\\) 个点，这 \\(k\\) 点将不能被选择。
分析
容斥
首先，必须注意此处的正方形可能是斜着摆放的。
然后我们可以考虑容斥。
若设 \\(f_i\\) 表示至少有 \\(i\\) 个顶点为坏点的正方形有多少种。
那么， \\(ans=f_0-f_1+f_2-f_3+f_4\\) 。
\\(f_0\\)
对于 \\(f_0\\) 的情况，事实上，即是假设所有点都是好点的情况。
我们发现，对于正着摆放的正方形，事实上，我们是不难求解的。看起来比较难处理的是斜着摆放的正方形，我们可以把它画出来。
我们发现，对于任何一个斜着摆放的正方形，我们都是能够画出一个正着摆放的正方形恰好把他框住，换句话来说，对于任何一个正着摆放的正方形，我们都能够在它的内部画出若干个斜着摆放的正方形。
那么我们就成功的把问题转化为了求解对于一个边长为 \\(x\\) 的正着摆放的正方形，会产生多少的贡献。
仔细观察上图，我们发现，确定一条边，从上面的任意一个格点，我们都是能够唯一确认一个正方形，这不难理解，有点类似于里面的正方形缓慢旋转的过程，在这个过程中我们需要维持的是四个角落形成的三角形全等，则每次移动会带动另外一条边上的顶点移动，刚好能够移动 \\(x-1\\) 次，再加上正着摆放的正方形本身，对于这样一个正方形，产生的贡献事实上就是 \\(x\\) 。
运用我们成功得到的这个结论，则：
\\(f_1\\)
接下来我们需要解决更复杂的正方形上至少有一个坏点的情况。
我们可以考虑枚举所有坏点 ，单独考虑每个坏点产生的贡献。
如图，我们从每个坏点建立一个坐标系。
首先，我们仍然先考虑这是一个正着摆放的正方形，则我们可以从这个坏点向四个方向分别延伸，变成逐渐扩大，最后得到的贡献不难求得。
那么对于斜着摆放的正方形了？上一个小问题中，我们知道了对于一个边长为 \\(x\\) 的正方形，从它边上的一个点出发，可以唯一确定一个正方形。
则我们又成功的将问题转化为，求有多少个正着的正方形的边上，会存在这个坏点，产生的贡献即是这种正方形的个数，由于我们前面考虑了在正着摆放的正方形顶点上的情况，所以接下来不考虑这个坏点是正着摆放正方形的顶点。
(图中的线段表示枚举的正方形的边长)
接下来，我们逐步考虑边长的情况。
首先，不失一般性的假设，\\(x<y\\) 。
显然，边长最小为 \\(2\\) ，即线段 \\(1\\) ，我们考虑将线段 \\(1\\) 逐步延伸，发现没增加 \\(1\\) ，对应的方案数也会增加 \\(1\\) ，缓慢向上延伸，直到边长为 \\(x+1\\) 时，方案数达到最大值，即我们的线段 \\(2\\) 。
之后，我们每一次扩大边长，实际上线段 \\(2\\) 能够向下移动的总步数也即是我们的总方案数不会变化进一步变化，始终维持在某个值上。
当达到 \\(y+2\\) 时，再次出现变化，也即是我们的线段 \\(3\\) 的下一次扩大，我们发现，这会让我们上移的步数也即是我们的方案数减少 \\(1\\) ，这个变化将持续到 \\(x+y\\) 也即是我们将整个正方形抵满。
我们的贡献最后其实形成了一个函数，大概长成这样：
第一段，如果能够完全取到，即为 \\(\\frac{x\\times(x+1)}{2}\\) 。
第二段，如果能够完全取到，即为 \\(x\\times(y-x)\\) 。
第三段，如果能够完全取到，即为 \\(\\frac{x\\times (x-1)}{2}\\) 。
注意这里说的是完全取到，什么时候不能完全取到，即不存在这个区间或者说目前取到的边长事实上已经超过了 \\(L\\) 的时候我们不能将这个区间的贡献全部一股脑的弄上去。
综上，如果设我们上述的函数为 \\(Get(x,y,z)\\) ，该坏点距离上边界的距离为 \\(u\\) ，下边界的距离为 \\(d\\) ，左边界的距离为 \\(l\\) ，右边界的距离为 \\(r\\) ，则：
\\(f_2\\)
到这里我们终于可以开始求 \\(f_2\\) 了。
首先，如果我们确定了两个坏点，事实上，我们就已经可以把这两个坏点能够形成的正方形给求解出来了。
具体如下图：
通过向量的知识或者其他的一些方法，我们能够求出其他两个点的坐标，这里就不再赘述了，属于是数学知识了。
求出另外两个点的坐标后，首先要注意这两个坐标可能不在格点上，对于这种我们是需要舍掉的。
然后再观察。
显然没有人想要再去求一下 \\(f_3\\) ，\\(f_4\\) ，有没有什么神奇的方法能把这两个东西删去。实际上是有的，我们可以手动给我们每个正方形的贡献加上一个系数。
具体可以举个例子说明。
假设，这个正方形上有三个坏点。
那其实，在 \\(f_0\\) 中，它被计算了 \\(+1\\) 次，在 \\(f_1\\) 中，由于每一个坏点都要确定一次它，它被计算了 \\(-3\\) 次，显然，我们期望 \\(f_2\\) 中，让它被计算 \\(+2\\) 次。
正好，我们是可以确定这个正方形的，换句话来说，我们能够确定这个正方形上的坏点个数，于是乎，我们能够“智能的”给他安排一个系数。
但是 \\(f_2\\) 本身中也有可能是会重复的，就像 \\(f_1\\) 一样，每两组会重复确定他一次，我们必须想办法规避这个问题，我们想到了给每个坏点打上一个编号，只要当这两个坏点确定出的正方形中，它们是编号最大的两个坏点时，我们才计算贡献，这样，我们就有效的规避了这个问题。
时间复杂度
求解 \\(f_0\\) 与 \\(f_1\\) 的时间复杂度都比较小，我们主要谈一谈求解 \\(f_2\\) 时的一些问题。
如果用 \\(map\\) 实现 \\(f_2\\) 中的一些操作，显然我们求 \\(f_2\\) 的复杂度是 \\(O(k^2logn)\\) 的，看起来非常可过，但其实应该是过不了的(指洛谷)，当然如果你常数小肯定也能过。我们需要优化这个 \\(log\\) ，要么用 \\(unorderedmap\\) ，要么使用离散化，都可以去掉这个 \\(log\\) 。
CODE
#include <bits/stdc++.h>
#include <unordered_map>
#define int long long
using namespace std;
const int N=1e5+10,M=2e3+10,MOD=1e8+7;
namespace IO {
int len = 0;
char ibuf[(1 << 20) + 1], *iS, *iT, out[(1 << 25) + 1];
#define gh() \\
(iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, (1 << 20) + 1, stdin), \\
(iS == iT ? EOF : *iS++) : *iS++)
inline int read() {
char ch = gh();
int x = 0;
char t = 0;
while (ch < \'0\' || ch > \'9\')
t |= ch == \'-\', ch = gh();
while (ch >= \'0\' && ch <= \'9\')
x = x * 10 + (ch ^ 48), ch = gh();
return t ? -x : x;
}
inline void putc(char ch) { out[len++] = ch; }
template <class T> inline void write(T x) {
if (x < 0)
putc(\'-\'), x = -x;
if (x > 9)
write(x / 10);
out[len++] = x % 10 + 48;
}
string getstr(void) {
string s = "";
char c = gh();
while (c == \' \' || c == \'\\n\' || c == \'\\r\' || c == \'\\t\' || c == EOF)
c = gh();
while (!(c == \' \' || c == \'\\n\' || c == \'\\r\' || c == \'\\t\' || c == EOF))
s.push_back(c), c = gh();
return s;
}
void putstr(string str, int begin = 0, int end = -1) {
if (end == -1)
end = str.size();
for (int i = begin; i < end; i++)
putc(str[i]);
return;
}
inline void flush() {
fwrite(out, 1, len, stdout);
len = 0;
}
} // namespace IO
using IO::flush;
using IO::getstr;
using IO::putc;
using IO::putstr;
using IO::read;
using IO::write;
struct node{
int x,y;
}p[M];
struct pair_hash
{
template<class T1, class T2>
std::size_t operator() (const std::pair<T1, T2>& p) const
{
auto h1 = std::hash<T1>{}(p.first);
auto h2 = std::hash<T2>{}(p.second);
return h1 ^ h2;
}
};
unordered_map<pair<int, int>, int, pair_hash> mp;
int n,m,k,cnt,ans;
inline bool cmp(node a,node b) { return a.y<b.y; }
inline int Get_val(int x,int y,int L)
{
int res=0;
if(x>y) swap(x,y);
// if(2<=x+1){
if(L<2) return 0;
else if(L>x+1) res=(res+((x+1)*x)/2)%MOD;
else return (L*(L-1))/2; //令x+1=L，则x=L-1
// }
// if(x+2<=y+1){
if(L>y+1) res=(res+x*(y-x))%MOD; //超出，加贡献
else return (res+(L-x-1)*x)%MOD; //令y+1=L
// }
// if(y+2<=x+y){
if(L>x+y) return (res+(x*(x-1))/2)%MOD;
else return (res+(2*x+y-L)*(L-y-1)/2)%MOD; //令x+y=L,则x=L-y
// }
}
signed main()
{
// while(1){
// int x=read(),y=read(),z=read();
// printf("%lld\\n",Get_val(x,y,z));
// }
n=read(),m=read(),k=read();
for(register int i=1;i<=k;i++){
pair<int,int> add;
p[i].x=read(),p[i].y=read();
add.first=p[i].x,add.second=p[i].y;
mp[add]=++cnt;
}
for(register int i=1;i<=min(n,m);i++) ans=(ans+i*(n-i+1)%MOD*(m-i+1)%MOD)%MOD;
//sort(p+1,p+k+1,cmp);
for(register int i=1;i<=k;i++){
for(register int j=i+1;j<=k;j++){ //枚举正方形
pair<int,int> a,b;
a.first=p[i].x,a.second=p[i].y;
b.first=p[j].x,b.second=p[j].y;
//printf("%d %d %d %d\\n",a.first,a.second,b.first,b.second);
int v=min(mp[a],mp[b]);
int temp,sum;
int x1=p[i].y,y1=n-p[i].x,x2=p[j].y,y2=n-p[j].x;
//printf("%d %d %d %d\\n",x1,y1,x2,y2);
int ny=x2-x1,nx=abs(y2-y1);
//printf("%d %d\\n",nx,ny);
if(y2>y1) ny*=-1;
pair<int,int> p1,p2;
//第一个正方形的两个新点
p1.first=n-(ny+y1),p1.second=nx+x1;
p2.first=n-(ny+y2),p2.second=nx+x2;
//printf("%d %d %d %d\\n",p1.first,p1.second,p2.first,p2.second);
if(p1.first>=0&&p1.second>=0&&p1.first<=n&&p1.second<=m){
if(p2.first>=0&&p2.second>=0&&p2.first<=n&&p2.second<=m){
temp=0,sum=0;
if(mp.find(p1)!=mp.end()) temp=max(mp[p1],temp),++sum;
if(mp.find(p2)!=mp.end()) temp=max(mp[p2],temp),++sum;
if(v>temp) ans=(ans+sum+1)%MOD;
}
}
//第二个正方形的两个新点
nx=-nx,ny=-ny;
p1.first=n-(ny+y1),p1.second=nx+x1;
p2.first=n-(ny+y2),p2.second=nx+x2;
if(p1.first>=0&&p1.second>=0&&p1.first<=n&&p1.second<=m){
if(p2.first>=0&&p2.second>=0&&p2.first<=n&&p2.second<=m){
temp=0,sum=0;
if(mp.find(p1)!=mp.end()) temp=max(mp[p1],temp),++sum;
if(mp.find(p2)!=mp.end()) temp=max(mp[p2],temp),++sum;
if(v>temp) ans=(ans+sum+1)%MOD;
}
}
//第三个正方形的两个新点
//if((x2-x1)*(y2-y1)==0) continue; //
nx=-nx,ny=-ny;
double dx=((x2-x1)/2.0-nx/2.0),dy=((y2-y1)/2.0-ny/2.0);
if((double)(dx-(int)dx)||(double(dy-(int)dy))) continue; //该正方形不存在
p1.first=n-(ny+dy+y1),p1.second=nx+dx+x1;
p2.first=n-(dy+y1),p2.second=dx+x1;
if(p1.first>=0&&p1.second>=0&&p1.first<=n&&p1.second<=m){
if(p2.first>=0&&p2.second>=0&&p2.first<=n&&p2.second<=m){
temp=0,sum=0;
if(mp.find(p1)!=mp.end()) temp=max(mp[p1],temp),++sum;
if(mp.find(p2)!=mp.end()) temp=max(mp[p2],temp),++sum;
if(v>temp) ans=(ans+sum+1)%MOD;
}
}
}
}
//cout<<ans<<"\\n";
for(register int i=1;i<=k;i++){
int u,d,l,r;
u=p[i].x,d=n-p[i].x,l=p[i].y,r=m-p[i].y;
int temp=(min(u,r)+min(r,d)+min(d,l)+min(u,l))%MOD;
ans=((ans-temp)%MOD+MOD)%MOD;
ans=((ans-Get_val(u,d,l))%MOD+MOD)%MOD;
ans=((ans-Get_val(u,d,r))%MOD+MOD)%MOD;
ans=((ans-Get_val(l,r,u))%MOD+MOD)%MOD;
ans=((ans-Get_val(l,r,d))%MOD+MOD)%MOD;
}
printf("%lld\\n",ans);
return 0;
}
-------------------------------------------
海到无边天作岸，山登绝顶我为峰！