2020.07.24 福州大学ACM/ICPC集训队选拔赛 部分题解
- 对于任何一个三角形 \(ABC\) ，令 \(f(A,B,C)\) 表示其三条边的三个中点构成的点集。
现在给定 \(f(A,B,C)\) 且满足所有坐标均为整数，试构造三角形 \(ABC\) 三个顶点坐标。
保证答案存在且唯一。
中位线定理可得，设三角形 \(DEF\) 对边的中点分别位 \(ABC\) ，则 \(\vec{BC}={1\over 2}\vec{FE}=\vec{FA}=\vec{AE}\)
因此，考虑求解 \(E\) 点坐标等价于求解 \(\vec{OE}\) 。则 \(\vec{OE}=\vec{OA}+\vec{AE}=\vec{OA}+\vec{OC}-\vec{OB}\)
不难知道，三角形两中点和减去第三个中点即可得到第三个中点对角的坐标。按这个方法写完排个序即可。
【代码】
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pii;
pii operator + (const pii &a,const pii &b) { return pii(a.first+b.first,a.second+b.second); }
pii operator - (const pii &a,const pii &b) { return pii(a.first-b.first,a.second-b.second); }
int main(){
pii Pnt[5];
for(int i=1;i<=3;i++) cin>>Pnt[i].first>>Pnt[i].second;
pii Ans[5];
Ans[1]=Pnt[1]+Pnt[2]-Pnt[3];
Ans[2]=Pnt[1]+Pnt[3]-Pnt[2];
Ans[3]=Pnt[2]+Pnt[3]-Pnt[1];
sort(Ans+1,Ans+4);
for(int i=1;i<=3;i++)
cout<<Ans[i].first<<" "<<Ans[i].second<<endl;
return 0;
}
- 给你两个长度为 \(len\leq 10^6\) 的由 01 组成的二进制字符串 \(n\) 和 \(m\) 定义 JC 的可爱值为：从 \(1\) 到 \(n\) 中选一个数 \(x\)，从 \(1\) 到 \(m\) 中选一个数 \(y\)，使得 \((x,y)\) 奇偶性不同的对数.
下面三个操作一直进行:
累加 JC 的可爱值.
字符串 \(n\) , \(m\) 失去他们最后一位，即 \(n=\lfloor{n\over 2}\rfloor,m=\lfloor{m\over 2}\rfloor\) ( \(\lfloor\rfloor\) 表示向下取整）.
如果 \(n=0\)，或 \(m=0\) 退出.
不难想出，要使得选出的 \((x,y)\) 奇偶性不同，则必然是 \(x\) 与 \(y\) 一个为奇数，一个为偶数
由于 \(n\) 中的奇数个数为 \(\lfloor{n+1\over 2}\rfloor\) ，偶数个数为 \(\lfloor{n\over 2}\rfloor\)
通过暴力找规律(写一个代码，算不同的 \(n,m\) 时，\((\lfloor{n+1\over 2}\rfloor\cdot \lfloor{m\over 2}\rfloor+\lfloor{n\over 2}\rfloor\cdot \lfloor{m+1\over 2}\rfloor)\) )亦或者稍微证明一下，不难发现，每个 \(n,m\) 对答案的贡献为 \(\lfloor{nm\over 2}\rfloor={nm-(n\&1)\cdot(m\&1)\over 2}\)
现只需考虑如何实现即可：由于 \(nm\) 的乘积在取模意义下等于两者各自的取模，再乘积的取模。\((n\&1)\cdot (m\&1)\) 仅与最后一位有关
故将串 \(n,m\) 前补足 \(0\) ，使得两者长度相同。然后从前往后，一边记录到当前位置 \(n,m\) 在取模意义下的值，一边计算对答案的贡献：若当前二进制位 \(n,m\) 均为 \(1\) ，则对答案的贡献为 \((nm-1)\mod p\) ，否则为 \(nm\mod p\) 。求和即可算出答案。
【代码】
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1e9+7,inv2=MOD+1>>1,MAXN=1e6+10;;
stack<int> num[3];
string s;
inline ll ans(){
for(int i=1;i<=2;i++){
getline(cin,s);
for(int j=s.size()-1;j>=0;j--)
num[i].push(s[j]=='1');
}
while(num[1].size()<num[2].size()) num[1].push(0);
while(num[1].size()>num[2].size()) num[2].push(0);
ll A=0,B=0,Ans=0;
for(int i=num[1].size();i>0;i--){
int a=num[1].top(); num[1].pop();
int b=num[2].top(); num[2].pop();
A=((A<<1)|a)%MOD;
B=((B<<1)|b)%MOD;
ll Tmp=A*B-(a&b);
Tmp=Tmp%MOD*inv2%MOD;
Ans=(Ans+Tmp)%MOD;
}
return Ans;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout<<ans()<<endl;
return 0;
}
- 胖达发现有 \(n\) 只熊猫在甜筒摊前排了一个队伍，从前往后依次编号为 \(1,2,\cdots n\)
胖达还发现，熊猫们不喜欢老实排队。每过一会儿，会有编号为 \(i\) 的熊猫从队伍里走出来并插到队伍的最前面去，或者从队伍里走出来并排到队伍的末尾
胖达很无聊，所以他时不时会问当前队伍从前往后第 \(i\) 个位置的熊猫的编号是多少
这题本人做法略微有些复杂，使用了分块+双端队列
将每 \(\sqrt n\) 只熊猫装在一个块内，每只熊猫维护一下当前它所在的块。当熊猫 \(i\) 走到队首时，我们可以对于熊猫 \(i\) 所在的块内暴力删除这个熊猫，再把它加到开头那个分块内。接着，从它原先在的块开始，把前一个块的最后一个弹出，扔进当前块内。记得在处理时更新一下被改动的熊猫所在的块。走到队尾也是类似的处理。
由于原先所在块内有 \(\sqrt n\) 只熊猫，暴力删除的复杂度是 \(O(\sqrt n)\) 的；对外每块末尾扔进后一个块，单次处理是 \(O(1)\) 的，总的次数是 \(O(\sqrt n)\) 次。因此修改的复杂度是 \(O(\sqrt n)\) 的。
查询当前第 \(i\) 只熊猫，可先从分块外扫过去，直到扫到查询熊猫所在分块；在进入分块暴力查询；也可直接用公式算出在第几个分块，然后进入暴力查询。
外面扫分块的复杂度为 \(O(\sqrt n)\) ，用公式直接算出在哪个分块是 \(O(1)\) 的；分块内暴力查询的复杂度是 \(O(\sqrt n)\) 的。因此查询的复杂度是 \(O(\sqrt n)\) 的。
因此，总复杂度为 \(O(q\sqrt n)\) 。过不了就卡卡常数。
【代码】
#include<bits/stdc++.h>
using namespace std;
const int MAXN=2e5+10;
typedef deque<int> dq;
int N,Q;
struct SQRT{
dq DQ;
inline void insertBack(int val) { DQ.push_back(val); }
inline void insertFront(int val) { DQ.push_front(val); }
inline int popBack(){
int res=DQ.back();
DQ.pop_back();
return res;
}
inline int popFront(){
int res=DQ.front();
DQ.pop_front();
return res;
}
inline void popElem(int val){
dq::iterator p=DQ.begin();
while(*p!=val) p++;
DQ.erase(p);
}
inline int ans(int pos){
for(auto e : DQ)
if(pos) pos--;
else return e;
}
};
struct MAIN{
int Siz;
int Cnt;
int Set[MAXN];
SQRT S[500];
inline void Front(int val){
int pos=Set[val],res;
S[pos].popElem(val);
for(int i=pos;i>0;i--){
res=S[i-1].popBack();
Set[res]=i;
S[i].insertFront(res);
}
S[0].insertFront(val);
Set[val]=0;
}
inline void Back(int val){
int pos=Set[val],res;
S[pos].popElem(val);
for(int i=pos;i<Cnt;i++){
int res=S[i+1].popFront();
Set[res]=i;
S[i].insertBack(res);
}
S[Cnt].insertBack(val);
Set[val]=Cnt;
}
inline int ans(int pos){
int Tot=0;
for(int i=0;i<=Cnt;i++)
if(pos>=Tot&&pos<Tot+Siz) return S[i].ans(pos-Tot)+1;
else Tot+=Siz;
}
}M;
inline void pre(){
cin>>N>>Q;
M.Siz=floor(sqrt(N));
M.Cnt=(N-1)/M.Siz;
for(int i=0;i<N;i++)
M.S[i/M.Siz].insertBack(i),M.Set[i]=i/M.Siz;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
int T,I;
while(Q--&&cin>>T>>I)
if(0);
else if(T==1) M.Front(I-1);
else if(T==2) M.Back(I-1);
else if(T==3) cout<<M.ans(I-1)<<endl;
return 0;
}
- 有一棵 \(n\) 个点，编号分别为 \(1\)～\(n\) 的树，其中 \(s\) 号点为根。
在树上养了很多松鼠，在第 \(i\) 个点上住了 \(A\) 个雄松鼠，\(B\) 个雌松鼠。
因为某些缘故，它们开始同时向根节点移动，但它们相当不安分，如果在同一个节点上，雄松鼠会和雌松鼠繁殖，简单地来说以下事件会依序发生：
这个点的 \(A\) 数量变成了 \(A+c\times B\)，这个点的 \(B\) 数量变成了 \(B+d\times A\)。
根节点的所有松鼠移动到地面，位于地面上的松鼠不会再繁殖；
所有松鼠同时朝它们的父节点移动。
所有事件各自都在一瞬间完成，直至树上没有松鼠。
现在想知道最终有多少只松鼠到达了地面。
题目有一些问题，理论上当 \(A,B\) 一位为 \(0\) 时，是不会繁殖的。但这题视为会繁殖，那就这样处理吧。
遍历一遍整棵树，不难发现，每个节点的松鼠只会遇到同一层的松鼠。而且根据分配律可证明（先挖坑，自己还没想明白），不论同一层的松鼠怎么分配，它们最后对答案的贡献；即为它们的和，乘上层数次（根节点为 \(1\) 层）的矩阵 \(\left( \begin{matrix} 1&C \\\ \\ D&1 \end{matrix} \right)\)
即第 \(n\) 层对答案的贡献为 \(\left( \begin{matrix} 1&C \\\ \\ D&1 \end{matrix} \right)^n\cdot \left( \begin{matrix} \displaystyle \sum_{dep_i=n}A_i \\\ \\ \displaystyle \sum_{dep_i=n}B_i \end{matrix} \right)\)
预处理出每一层对总和 \(A,B\) 的贡献，矩阵的乘方可以递推，累加起来即是答案。
【代码】
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1e9+7,MAXN=1e5+10;
struct Matrix{
ll Num[2][2];
Matrix() { Num[0][0]=Num[0][1]=Num[1][0]=Num[1][1]=0; }
Matrix operator * (const Matrix &x) const {
Matrix y;
for(int i=0;i<2;i++)
for(int j=0;j<2;j++)
for(int k=0;k<2;k++)
y.Num[i][j]=(y.Num[i][j]+Num[i][k]*x.Num[k][j])%MOD;
return y;
}
Matrix operator + (const Matrix &x) const {
Matrix y;
for(int i=0;i<2;i++)
for(int j=0;j<2;j++)
y.Num[i][j]=(Num[i][j]+x.Num[i][j])%MOD;
return y;
}
}Bas,Dep[MAXN],Mul,Ans;
ll N,S,C,D,A[MAXN],B[MAXN];
vector<int> Edg[MAXN];
void dfs(int pos,int pa,int fl){
Dep[fl].Num[0][0]+=A[pos];
Dep[fl].Num[1][0]+=B[pos];
for(auto to : Edg[pos])
if(to!=pa)
dfs(to,pos,fl+1);
}
inline void pre(){
ios::sync_with_stdio(0);
cin.tie(0);
cin>>N>>S>>C>>D;
for(int i=1;i<N;i++){
int u,v;
cin>>u>>v;
Edg[u].push_back(v);
Edg[v].push_back(u);
}
for(int i=1;i<=N;i++) cin>>A[i]>>B[i];
Bas.Num[0][0]=1;
Bas.Num[0][1]=C;
Bas.Num[1][0]=D;
Bas.Num[1][1]=1;
Mul.Num[0][0]=1;
Mul.Num[1][1]=1;
dfs(S,0,1);
}
int main(){
pre();
for(int i=1;i<=N;i++){
Mul=Mul*Bas;
Ans=Ans+Mul*Dep[i];
}
cout<<(Ans.Num[0][0]+Ans.Num[1][0])%MOD<<endl;
return 0;
}
- 有一个碗状容器高度为 \(H\) ，容器厚度不计，用任一平行于底的水平平面截取碗得到的都是圆，且半径 \(r(h)\) 满足： \(r(h)=r_0+e^h,h\in [0,H]\)
其中 \(h\) 为水平截面到底部的距离，\(e\) 为自然对数。
给定 \(k\) ，求使得容器恰好储水总容量的 \({1\over k}\) 时的水面高度 \(h_k\) 。
不难列出方程 \(\displaystyle {1\over k}\int_0^H\pi r^2(h)\text dh=\int_0^{h_k}\pi r^2(h)\text dh\)
令变上限函数 \(\displaystyle f(x)=\int_0^x r^2(h)\text dh\) 则不难整理出 \({1\over k}f(H)=f(h_k)\)
由于 \(f'(x)=r^2(x)\geq 0\) 故 \(f(x)\) 单调递增，可以二分
又因为 \(\displaystyle f(x)=\int_0^x (r_0+e^h)^2\text dh=({1\over 2}e^{2h}+2r_0e^h+r_0^2h)|^x_0={1\over 2}(e^{2x}-1)+2r_0(e^x-1)+r_0^2x\) 其他的就二分可出答案
当然，由于精度要求较低，且 \([0,H]\) 枚举范围较小，可以直接 for 循环处理
【代码】
#include<bits/stdc++.h>
using namespace std;
const double esp=1e-6;
double r0,H,K;
inline double f(double x){
return 0.5*(exp(2*x)-1)+(exp(x)-1)*2*r0+r0*r0*x;
}
int main(){
cin>>r0>>H>>K;
double Y=f(H)/K;
double Head=0,Tail=H,Mid,Ans=0;
while(Tail-Head>esp){
Ans=Mid=(Head+Tail)/2;
double y=f(Mid);
if(y>Y) Tail=Mid;
else Head=Mid;
}
printf("%0.2f",Ans);
return 0;
}
- 有 \(n\) 个人(编号 \([1,n]\) )，每个人说了一句话。第 \(i\) 个人说话内容为 \(j,v\) ，当 \(v=1\) 表示第 \(i\) 个人说第 \(j\) 个人说的是真话，若 \(v=0\) 表示说的是假话，若 \(v=−1\) 表示第 \(i\) 个人说不知道第 \(j\) 个人的话是真还是假。
这 \(n\) 个人说的句话，每个人说的要么是真的，要么是假的，问共有多少种不同的可能？由于答案很大，请将答案对 \(k\) 取模
类似于食物链。当 \(v_i=1\) 时，分别连接 \(i,j_i\) 与 \(\neg i,\neg j_i\) ；表示若第 \(i\) 个人说的是真话，则第 \(j_i\) 个人说的是真话；若第 \(i\) 个人说的是假话，则第 \(j_i\) 个人说的是假话。
同理，当 \(v_i=0\) 是，分别连接 \(i,\neg j_i\) 与 \(\neg i,j_i\) ；\(v_i=-1\) 的不处理。
则若存在 \(i\) 使得 \(i,\neg i\) 处于同一并查集内，一定无解。一个人不能既说真话，又说假话。此时返回 \(0\) 。
否则，若第 \(i\) 个人说了真话，则所有与它处于同一并查集的情况都应视为成立。故统计总并查集的数量 \(Cnt\) ，答案即为 \(2^{Cnt\over 2}\) （每个人说真话和说假话都会统计到一次）
【代码】
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAXN=2e6+10;
ll N,K;
inline ll fpow(ll a,ll x){
ll ans=1;
for(;x;x>>=1,a=a*a%K) if(x&1) ans=ans*a%K;
return ans;
}
ll Pa[MAXN],Vis[MAXN];
int pa(int n) { return (n==Pa[n])?n:(Pa[n]=pa(Pa[n])); }
inline void merge(int u,int v) { Pa[pa(u)]=pa(v); }
inline bool isunion(int u,int v) { return pa(u)==pa(v); }
inline void pre(){
cin>>N>>K;
ll J,V;
for(int i=1;i<=N+N;i++) Pa[i]=i,Vis[i]=0;
for(int i=1;i<=N;i++){
cin>>J>>V;
if(V==-1) continue;
else if(V==1) merge(i,J),merge(i+N,J+N);
else if(V==0) merge(i+N,J),merge(i,J+N);
}
}
inline ll ans(){
ll Cnt=0;
for(int i=1;i<=N;i++)
if(isunion(i,i+N)) return 0;
else if(!Vis[pa(i)]){
Vis[pa(i)]=1;
Vis[pa(i+N)]=1;
Cnt++;
}
return fpow(2,Cnt);
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
pre();
cout<<ans()<<endl;
return 0;
}
- 白熊有一个长度为 \(n\) 的数组 \(a_1,a_2,\cdots ,a_n\) 。
白熊觉得这个数组的长度太短了，所以白熊想要在这个数组的末尾再添加 \(m\) 个数。
白熊觉得只是添加 \(m\) 个数太无聊了，它希望数组在添加了 \(m\) 个数之后，包含的本质不同的非空子序列尽可能多。
白熊只认识从 \(1\) 到 \(k\) 的 \(k\) 个整数，因此数组中原有的 \(n\) 个数与将要添加的 \(m\) 个数均为不超过 \(k\) 的正整数。
白熊希望你告诉它，在添加了 \(m\) 个数后，新数组最多可以包含多少个本质不同的非空子序列，你只需要告诉它答案对 \(1000000007\) 取模后的结果。
一个数组的非空子序列是指将这个数组中的某些数删去后（可以不删，但不能全部删去），剩下的数构成的序列。对于两个序列 \(p,q\) , 它们本质相同当且仅当 \(p,q\) 长度相等且对于所有下标 \(i\) 满足 \(p_i=q_i\) 。
比如，数组 \([1,3,3]\) 的非空子序列有7个: \([1], [3], [3], [1,3], [1,3], [3,3], [1,3,3]\) ，本质不同的非空子序列有5个: \([1], [3], [1,3], [3,3], [1,3,3]\) 。
考虑 \(dp_n\) 表示仅使用前 \(n\) 个数（可不全使用），构成的本质非空子序列数个数。
先考虑 \(m=0\) 的情况：
则若当前数字 \(a_n\) 未出现过，则 \(dp_n=2dp_{n-1}+1\) ：之前的每个非空序列都对 \(dp_n\) 有贡献，大小为 \(dp_{n-1}\) ；后接数字 \(a_n\) 也对 \(dp_n\) 有贡献，大小为 \(dp_{n-1}\) ；再考虑上数字 \(a_n\) 自己作为一个子序列，会与之前的序列均不同，贡献为 \(1\) 。
若当前数字 \(a_n\) 出现过，设之前最后一次的出现位置为 \(lst_{a_n}\) ，则对 \(dp_n\) 的贡献可理解为 \(2dp_{n-1}+1\) 扣去重复的部分：数字 \(a_n\) 自己作为子序列的，与前面的重复了，扣除 \(1\) ；还有需要扣除的，就是前 \((lst_{a_n}-1)\) 个位置的非空子序列，后接当前数字 \(a_n\) 的序列重复，故再扣除 \(dp[lst_{a_n}-1]\) 。
总结一下公式：若初始化 \(lst_{num}=0\) 则
\(dp_n=\begin{cases} 2dp_{n-1}+1,lst_{a_n}=0 \\\ \\ 2dp_{n-1}-dp[lst_{a_n}-1],lst_{a_n}\neq 0 \end{cases}\)
这里可以发现：若 \(dp_{1\cdots (n-1)}\) 单调递增，若 \(a_n\) 未出现过，则 \(dp_n=2dp_{n-1}+1>dp_{n-1}\) ；若 \(a_n\) 出现过，则 \(dp_n=2dp_{n-1}-dp[lst_{a_n}-1]>dp_{n-1}+dp_{n-1}-dp_{n-1}=dp_{n-1}(lst_{a_n}<n-1\Rightarrow dp[lst_{a_n}-1]<dp[n-1-1]<dp[n-1])\) 。
又因为 \(dp_0=0,dp_1=2dp_0+1=1>dp_0\) ，故数学归纳法得序列 \(dp_{1\cdots n}\) 单调递增。
接下来我们考虑 \(m\neq 0\) 的情况：
由上面式子易得，若 \(a_n\) 未出现过，则对 \(dp_n\) 的贡献一定更大。故我们优先选择填涂未出现过的元素。
当 \([1,k]\) 均出现过，则转移方程退化为 \(dp_n=2dp_{n-1}-dp[lst_{a_n}-1]\) 。显然 \(dp[lst_{a_n}-1]\) 越小则对 \(dp_n\) 的贡献越大。因此我们每次需要求出最小的 \(lst_{a_n}\) ，之后我们填涂 \(a_n\) ，那么 \(lst_{a_n}\) 更新为当前的 \(n\) 。
因此，我们只需要用堆维护 \(lst_{a_{1\cdots k}}\) ，每次弹出最小值参加转移方程，之后重新插入 \(n\) 即可。
【代码】
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1e9+7,MAXN=2e5+10;
ll N,M,K,A,Dp[MAXN<<1],Lst[MAXN];
priority_queue<ll> pq;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin>>N>>M>>K;
for(int i=1;i<=N;i++){
cin>>A;
if(Lst[A])
Dp[i]=(Dp[i-1]*2-Dp[ Lst[A]-1 ])%MOD;
else Dp[i]=(Dp[i-1]<<1|1)%MOD;
Lst[A]=i;
}
for(int i=1;i<=K;i++) pq.push(-Lst[i]);
for(int j=1,i=N+1;j<=M;j++,i++){
if(pq.top())
Dp[i]=(Dp[i-1]*2-Dp[ -pq.top()-1 ])%MOD;
else Dp[i]=(Dp[i-1]<<1|1)%MOD;
pq.pop();
pq.push(-i);
}
cout<<(Dp[N+M]+MOD)%MOD<<endl;
return 0;
}
- 给定 \(n\) ，和 \(n\) 个非负整数构成序列 \(a[1\cdots n]\) 。
对于序列 \(a\) ，定义集合 \(S(a)\) 表示序列 \(a\) 生成的集合，通过以下步骤任意多次：
1.初始，\(S(a)={a_i},i\in [1,n]\)
2.若存在 \(x,y\in S(a)\) ，但是 \(x\oplus y\not\in S(a)\) ，将其插入到 \(S(a)\) 中
定义一个集合S和非负整数x的或运算和与运算分别为：
\(S∣x=\{y∣x ∣ y\in S\}, S\&x=\{y\&x ∣ y\in S\}\)
有 \(q\) 组询问，每组询问为以下两种类型之一：
\(1\) \(L\) \(R\)，令\(f_1(x)=S∣x\) ，求当 \(x\in [L,R]\) 时，本质不同的 \(f_1(x)\) 的个数，即求： \(∣\{f_1(x)∣x\in [L,R]\}∣\)
\(2\) \(L\) \(R\), 令\(f_2(x)=S\&x\) ，求当 \(x\in [L,R]\) 时，本质不同的 \(f_2(x)\) 的个数，即求： \(∣\{f_2(x)∣x\in [L,R]\}∣\)
现证明，对于第一种询问，答案一定为 \((R-L+1)\) ：
对于 \(\forall x_1\neq x_2\) ，考虑是否 \(f_1(x_1)=f_1(x_2)\) ：
很显然 \(x=0|x\in S|x=f_1(x)\)
若 \(x_2\not\in f_1(x_1)\) 又因为 \(x_2\in f(x_2)\) 故 \(f(x_1)\neq f(x_2)\)
若 \(x_2\in f_1(x_1)\) ，我们将 \(x\) 视为它二进制位的集合。例如 \(9=1001_{(2)}\) 可视为集合 \(\{0,3\}\) 。为方便描述，记为 \(\boldsymbol 9=\{0,3\}\) 。那么此时，必然有 \(\boldsymbol {x_1}\subset \boldsymbol{x_2}\) 。否则，不妨设 \(a\in \boldsymbol{x_1},a\not\in \boldsymbol{x_2}\) ，则对于 \(\forall n \in f_1(x_1),\exist t\in S\) 使得 \(n=t|x_1\) 即
\(\boldsymbol{n}=\boldsymbol{t}\cup \boldsymbol{x_1}\) 故 \(a\in \boldsymbol{n}\) 恒成立。因为 \(x_2\in f_1(x_1)\) ，故 \(a\in \boldsymbol{x_2}\) ，与假设矛盾。
因此 \(\boldsymbol{x_1}\subset \boldsymbol{x_2}\) 又因为 \(x_1\neq x_2\) 故 \(\exist a\not\in \boldsymbol{x_1},a\in \boldsymbol{x_2}\) 。此时同上可得 \(\forall n\in f_1(x_2)\) 都有 \(a\in \boldsymbol{n}\) 。因此可得 \(x_1\not\in f_1(x_2)\) 。又因为 \(x_1\in f_1(x_1)\) 故 \(f_1(x_1)\neq f_1(x_2)\)
综上，对于 \(\forall x_1\neq x_2,f(x_1)\neq f(x_2)\) ，故对于不同的 \(x\in[L,R]\) ，\(f_1(x)\) 并不相同。因此 \(|\{f_1(x)|x\in [L,R]\}|=|\{x|x\in [L,R]\}|=R-L+1\) 。
对于 \(\forall x_1,x_2\) ,我们考虑何时有 \(f_2(x_1)\neq f_2(x_2)\) ：
