算法 {逐维度扫描网格空间(SOS DP)}

已于 2024-05-18 19:32:30 修改
阅读量794 收藏 8
点赞数 17
分类专栏： 算法 文章标签： 算法
于 2024-04-16 23:16:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66485519/article/details/137844526
版权

算法 {逐维度扫描网格空间(SOS DP)}

@LOC_3

逐维度扫描网格空间(SOS DP)

定义

SOS: Sum On Subsets, 他是表示 空间所有维度的大小都是2的特例, (即整个空间可以用一个二进制ST来表示 空间所有点都是ST的子集), 所以这个名字SOS DP 并不是完全表示这个算法, 因为这个算法 可以处理任意的高维度网格空间, 所以名字起成逐维度扫描网格空间 比较好;

朴素做法 即容斥原理 他是M * (2^N) (令空间点数为M 空间维度为N), 而使用这种算法 时间是M * N;

#构造网格空间的前缀和#
比如空间维度为`{X,Y,Z}`, 我们要让`Sum`构造成原数组`A`的前缀和数组;
1: Sum = A;
`.` 此时`Sum(x,y,z)`等于`A(x,y,z)`之和;
2: 扫描第一个维度(X), 令`Sum(x,y,z) += Sum(x-1,y,z)`(从小到大);
`.` 此时`Sum(x,y,z)`等于`A(<=x,y,z)`之和;
3: 扫描第二个维度(Y), 令`Sum(x,y,z) += Sum(x,y-1,z)`(从小到大);
`.` 此时`Sum(x,y,z)`等于`A(<=x,<=y,z)`之和;
4: 扫描第三个维度(Z), 令`Sum(x,y,z) += Sum(x,y,z-1)`(从小到大);
`.` 此时`Sum(x,y,z)`等于`A(<=x,<=y,<=z)`之和;

@DELI;

#构造网格空间的差分#
比如空间维度为`{X,Y,Z}`, 我们要让`Diff`构造成原数组`A`的差分数组(因为A是前缀和数组 我们令B为A的原数组 也就是A是B的前缀和数组 即最终我们要让`Diff==B`);
1: Diff = A;
`.` 此时`Diff(x,y,z)`等于`B(<=x,<=y,<=z)`之和;
2: 扫描第一个维度(X), 令`Diff(x,y,z) -= Diff(x-1,y,z)`(从大到小);
`.` 此时`Diff(x,y,z)`等于`B(x,<=y,<=z)`之和;
3: 扫描第二个维度(Y), 令`Diff(x,y,z) -= Diff(x,y-1,z)`(从大到小);
`.` 此时`Diff(x,y,z)`等于`B(x,y,<=z)`之和;
4: 扫描第三个维度(Z), 令`Diff(x,y,z) -= Diff(x,y,z-1)`(从大到小);
`.` 此时`Diff(x,y,z)`等于`B(x,y,z)`之和;

算法

模板

@LINK: (https://editor.csdn.net/md/?articleId=137930238);

错误

下面的笔记里面的内容, 有一点是错误的, 即DP转移是错误的;
比如当前在枚举(x,[y], z)中的y维度, 下面笔记里的做法 是获取preDP[0,1,2,3,...,y-1], 但其实 他可以变成O(1) 即直接获取curDP[y-1]即可;

笔记

#SOS DP#

定义

SOS DP, 他的用处 是求网格空间的前缀和\差分的一种算法(另一种算法是容斥原理);
构造前缀和, 其实除了容斥原理, 还可以通过逐维度扫描的方式:

空间[X][Y]:
1: Sum = A;
2: 扫描第一维度: FOR( x : [0,X))  FOR( y : [0,Y)) Sum[x][y] += Sum[x-1][y];
3: 扫描第二维度: FOR( x : [0,X))  FOR( y : [0,Y)) Sum[x][y] += Sum[x][y-1];

扫描第一维度后, 此时Sum(x,y) 他的值 是A(<=x, y)之和;
扫描第二维度后, 此时Sum(x,y) 他的值 是A(<=x, <=y)之和;

1: Sum Of Subsets: SOS 子集DP
. 等价于: 网格空间的(可变长K进制)求前缀和/差分;

2: Sum Of Supersets: SPS 超集DP (@TODO;
. 他应该可以转换为 SOS 子集DP把?

算法

高维空间前缀和

@LINK: @MARK_1;

@DELI;

#SOS 子集DP/网格空间的前缀和#
@MARK_1;

定义

当然可以用朴素的容斥原理做法, 时间是...;

int DP[ Dimens.size()+1][ STs];
{
    FOR_( st, 0, STs-1){
        auto cor = Get_coordinate(st);
        DP[0][st] = A[cor[0]][cor[1]][cor[2]];
    }
    FOR_( dpI, 1, Dimens.size()){
        auto & curDP = DP[ dpI];
        auto const& preDP = DP[ dpI-1];
        FOR_( dpJ, 0, STs-1){
//                    Debug_::__IsOpenedDebug = (dpI==2 && dpJ==1);
            curDP[ dpJ] = preDP[ dpJ];
            auto cor = Get_coordinate( dpJ);
//                    DE_( curDP[dpJ], cor);
            FOR_( p, 0, cor[dpI-1]-1){
                auto pp = cor;  pp[ dpI-1] = p;
                curDP[ dpJ] += preDP[ Get_st(pp)];
            }
        }
    }
}

性质

对于Get_subSpace, 他俩都一样; 唯一的区别就在于Work()函数, 即构造前缀和的过程;

算法

可变长K进制

定义

&Dim: 空间各个维度 (比如&Dim=[2,5,4], 表示三维空间 所有点范围是([0-1], [0-4], [0-3]));

耗时为: O( 空间总点数 * 维度 * 维度最大值) (比如&Dim=[2,5,4], 则为O( 2*5*4 * 3 * 5));

@TODO

其实状态 没必要用vector<int>来存, 因为__PointsCount肯定不会很大 你就用int来存就可以 (表示变长K进制);
效仿2进制的做法 Initialize( {2,4,3}, T * val), 则val的范围是[0, 2*4*3) (没必要写一个INitialze_setValue);

代码
template< class _SumValueType> class ___PrefixSum_xD_sosDP_kRadix{
//< 给定可变长K进制(也可解释为空间维度), (比如变长K进制为`{2,4,3}` 表示空间是3维 坐标范围为`([0-2),[0-4),[0-3))`, 点`(x,y,z)`的数值为`x*12+y*3+z`);  令`&Subs(x): x的所有子集`(比如`&Subs(120)={120,110,020,100,010,000}` 即`&Subs((x,y,z))为所有([0-x],[0-y],[0-z])的点);
//  #代码#: `Initialize()` -> `Initialize_setValue()` -> `Work()`;
public:
    std::vector<_SumValueType> __RawArray; // 原始数组;
    std::vector<_SumValueType> __Sum_subsets; // `Sum_subsets[(x,y,z)]`: 表示所有`([0-x], [0-y], [0-z])`点的价值和(即和普通数组前缀和一样);
    std::vector<int> __Dimensions; // 可变长K进制(也可解释为空间维度);
    int __PointsCount; // 空间总点数;  空间所有点 其对应的数值范围是`[0, PointsCount)`

    int __GetID( std::vector<int> const& _cor) const{ int ANS = 0;  for( int i = 0; i < (int)_cor.size(); ++i){ ANS *= __Dimensions[i]; ANS += _cor[i];}  return ANS;}
    std::vector<int> __GetCoordinate( int _id) const{ std::vector<int> ANS;  for( int i = __Dimensions.size()-1; i >= 0; --i){ ANS.push_back( _id % (__Dimensions[i]));  _id /= __Dimensions[i];} std::reverse( ANS.begin(), ANS.end());  return ANS;}
    void Initialize( std::vector<int> const& _dimensions){
        __Dimensions = _dimensions;
        __PointsCount = 1;  for( auto i : __Dimensions){ __PointsCount *= i;}
        __RawArray.resize( __PointsCount);  std::memset( __RawArray.data(), 0, sizeof(__RawArray[0])*__RawArray.size());
    }
    void Initialize_setValue( std::vector<int> const& _cor, _SumValueType _val){
        ASSERT_SYSTEM_( _cor.size() == __Dimensions.size());  for( int i = 0; i < (int)_cor.size(); ++i){ ASSERT_SYSTEM_( _cor[i]>=0 && _cor[i]<__Dimensions[i]);}
        __RawArray[ __GetID(_cor)] = _val;
    }
    void Work(){
        __Sum_subsets.resize( __RawArray.size());  std::memcpy( __Sum_subsets.data(), __RawArray.data(), sizeof(__RawArray[0])*__RawArray.size());
        for( int dpI = 1; dpI <= (int)__Dimensions.size(); ++dpI){
            for( int dpJ = __PointsCount-1; dpJ >= 0; --dpJ){
                auto cor = __GetCoordinate( dpJ);
                for( int p = 0; p < cor[dpI-1]; ++p){
                    int raw = cor[dpI-1];  cor[ dpI-1] = p;
                    __Sum_subsets[ dpJ] += __Sum_subsets[ __GetID(cor)];
                    cor[ dpI-1] = raw;
                }
            }
        }
    }
    _SumValueType Get_sum_subSets( std::vector<int> const& _r) const{ // 获取`r`的所有子集的价值和 (比如`r==[1,2,0]`, 则返回值为`{120,110,020,100,010,000}`这些点的价值之和);
        ASSERT_SYSTEM_( _r.size() == __Dimensions.size());  for( int i = 0; i < (int)_r.size(); ++i){ ASSERT_SYSTEM_( _r[i]>=0 && _r[i]<__Dimensions[i]);}
        return __Sum_subsets[ __GetID(_r)];
    }
    _SumValueType Get_sum_middleSets( std::vector<int> const& _corL, std::vector<int> const& _corR) const{ // 获取所有介于`[corL, corR]`之间的点的价值之和; (比如`corL=[1,2,0], corR=[2,4,0]` 则表示`{120|130|140|220|230|240}`这些点的价值之和;
        ASSERT_SYSTEM_( _corL.size()==_corR.size() && (_corL.size()==__Dimensions.size()));
        for( int i = 0; i < (int)_corL.size(); ++i){ ASSERT_SYSTEM_( _corL[i]<=_corR[i]);}
        _SumValueType ANS = 0;
        auto cor = _corR;
        for( int mask = 0; mask < (1<<__Dimensions.size()); ++mask){
            for( auto t = mask; t != 0;){
                auto bit = __builtin_ctz( t); t ^= (1<<bit);
                cor[ bit] = _corL[bit] - 1;
            }
            bool valid = 1;
            for( auto i : cor){ if( i < 0){ valid=0; break;}}
            if( valid){
                if( __builtin_popcount(mask) & 1){ ANS -= __Sum_subsets[ __GetID(cor)];}
                else{ ANS += __Sum_subsets[ __GetID(cor)];}
            }
            for( auto t = mask; t != 0;){
                auto bit = __builtin_ctz( t); t ^= (1<<bit);
                cor[ bit] = _corR[bit];
            }
        }
        return ANS;
    }
}; // class ___PrefixSum_xD_sosDP_kRadix

2进制

@MARK(0);

定义

这是可变长K进制的特例, 即当K==2的特例; 代码中的__Bits他, 就对应变长K进制里的 空间维度;
. 比如__Bits = 3, 他对应可变长K进制算法里的空间维度为{2,2,2};
时间为2^N * N (N为二进制长度);

性质
代码
template< class _Type_> struct ___PrefixSum_xD_sosDP_binary{
    std::vector<_Type_> PrefixSum; // `PrefixSum[101] = _rawArray[000|001|100|101]之和`;
    int __Bits; // 空间的维度; 比如`Bits=3` 表示空间所有点是`([0-1],[0-1],[0-1])`;

    void Initialize( _Type_ const* _rawArray, int _bits){ // `_rawArray`的范围是`[0, (1<<bits))`;
        __Bits = _bits;
        PrefixSum.resize( 1<<_bits);  std::memcpy( PrefixSum.data(), _rawArray, sizeof(PrefixSum[0])*PrefixSum.size());
        for( int dpI = 1; dpI <= __Bits; ++dpI){ // SOS_DP (`Sum_subsets`其实是`[Bits][1<<Bits]`的DP 只不过把`[Bits]`给数组压缩了);
            for( auto dpJ = (1<<__Bits)-1; dpJ >= 0; --dpJ){
                if( (dpJ>>(dpI-1)) & 1){ PrefixSum[ dpJ] += PrefixSum[ dpJ^(1<<(dpI-1))];}
            }
        }
    }
    _Type_ Get_sum_middleSets( int _l, int _r) const{ // `&S: [l的超集]&&[r的子集]` 返回值为`RawArray[&{S}]`之和; (比如`l=010, r=110`, 则`&{S}=={010,110}`);
        ASSERT_SYSTEM_( (_l&((1<<__Bits)-1)==_l) && (_r&((1<<__Bits)-1)==_r) && (_l<=_r));
        ASSERT_SYSTEM_( _l != 0); // 请直接调用`Sum_subsets[_r]`;
        _Type_ ANS = 0;
        for( int mask = 0; mask < (1<<__Bits); ++mask){
            int cur = _r;
            bool valid = 1;
            for( auto t = mask; t != 0;){
                auto bit = __builtin_ctz( t); t ^= (1<<bit);
                if( (_l>>bit) & 1){ Integer_::Binary_::SetBit( cur, bit, 0);}
                else{ valid = 0; break;}
            }
            if( valid){
                if( __builtin_popcount(mask) & 1){ ANS -= PrefixSum[ cur];}
                else{ ANS += PrefixSum[ cur];}
            }
        }
        return ANS;
    }
}; // class ___PrefixSum_xD_sosDP_binary

应用

@LINK: https://editor.csdn.net/md/?articleId=137920019;

@DELI;

#SOS 子集DP/网格空间的差分#

定义

已知&Dim: 空间维度; 已知&Sum: &ANS的前缀和数组; 求&ANS: 原始数组;
. 比如&Dim=[2,5,4], 则&Sum[ (0,1,1)] = &ANS[ (0,1,1)] + &ANS[ (0,1,0)] + &ANS[ (0,0,1)] + &ANS[ (0,0,0)];

当然可以用朴素的空间差分(容斥原理), 但时间是2^N * 2^N(N为空间维度);
而使用SOS_DP, 时间为O(2^N * M) (M为MAX( {&Dim[i]} ));

不从算法层面来证明了(应该很复杂…), 而是代码层面来推导; 因为&Sum是可以通过&ANS做SOS_DP来构造的, 所以 那么我们对&Sum做逆向的 SOS_DP 不就可以还原出原始数组&ANS啦;

算法

可变长K进制

@TODO;

2进制

@MARK_2;

定义

时间是O( 2^N * N); (N为空间维度 即二进制长度);

代码
template< class _Type_> struct  ___Differential_xD_sosDP_binary{
    std::vector<_Type_> Differential; // `_rawArray[101] = Differential[000|001|100|101]之和`;
    int __Bits; // 空间的维度; 比如`Bits=3` 表示空间所有点是`([0-1],[0-1],[0-1])`;

    void Initialize( _Type_ const* _rawArray, int _bits){ // `_rawArray`的范围是`[0, (1<<bits))`;
        __Bits = _bits;
        Differential.resize( 1<<_bits);  std::memcpy( Differential.data(), _rawArray, sizeof(Differential[0])*Differential.size());
        for( int dpI = 1; dpI <= __Bits; ++dpI){ // SOS_DP (`Sum_subsets`其实是`[Bits][1<<Bits]`的DP 只不过把`[Bits]`给数组压缩了);
            for( auto dpJ = (1<<__Bits)-1; dpJ >= 0; --dpJ){
                if( (dpJ>>(dpI-1)) & 1){ Differential[ dpJ] -= Differential[ dpJ^(1<<(dpI-1))];}
            }
        }
    }
    void Modify_middleSets( int _l, int _r, _Type_ _add) const{ // `&S: [l的超集]&&[r的子集]`; `&Raw: Differential对应的前缀和数组`;  我们会修改`&Raw[ &S] += _add`; (比如`l=010, r=110`, 则`&S=={010,110}`);
        ASSERT_SYSTEM_( (_l&((1<<__Bits)-1)==_l) && (_r&((1<<__Bits)-1)==_r) && (_l<=_r));
        ASSERT_SYSTEM_( _l != 0); // 请直接调用`Sum_subsets[_r]`;
        TODO_RunTime_( "not finished");
        for( int mask = 0; mask < (1<<__Bits); ++mask){
            int cur = _r;
            bool valid = 1;
            for( auto t = mask; t != 0;){
                auto bit = __builtin_ctz( t); t ^= (1<<bit);
                if( (_l>>bit) & 1){ Integer_::Binary_::SetBit( cur, bit, 0);}
                else{ valid = 0; break;}
            }
            if( valid){
                if( __builtin_popcount(mask) & 1){}
                else{ }
            }
        }
    }
}; // class ___Differential_xD_sosDP_binary

应用

@LINK: https://editor.csdn.net/md/?articleId=137920019;

omipus
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于遗传算法的空间网格划分匿名算法
04-30
针对当LBS用户发送查询时，用户的个人隐私可能会泄露给攻击者的问题，提出了基于遗传算法的空间网格划分的隐私保护算法（GAGP）。算法包括两个方法，即地图分割算法和假名生成法。地图分割算法利用遗传算法给每个...
【强基】SOS DP（子集 DP）
xishanmeigao2918的博客
08-23 576
1、例题引入：给定一个含 2^N个整数的集合 A，我们需要计算：∀x⊆A，x 中所有元素 i 的 A[i] 的和，即求：F[mask]= i⊆mask∑A[i]
SOS DP
海边拾贝，沧海一粟
08-27 8858
SOSdp (sum of subsets dynamic programming)
SOS_dp算法
qq_35975367的博客
10-23 745
Codeforces博客 简介： 前置知识：状压dp Sum over Subsets dynamic programming，简称Sos dp,状压dp的一种 用一个列题引出SOS dp： 给你一个由2N2^N2N个整数组成的确定数组A，我们需要计算对于任意的x，F(x)=所有A[i]的和sumF(x)=所有A[i]的和sumF(x)=所有A[i]的和sum且x&i=i,i是x的子集 整理成公式就是： F[mask]=∑i∈maskA[i]F[mask]=\sum_{i∈mask}A[i]F[ma
SOS DP（子集DP）（高维前缀和）
最新发布
christ_lrs的博客
03-16 1689
它是一种基于前缀和的子集求和；他是属于状压DP的一个分支；他是一个优化的子集运算的方法。
SOSDP(子集DP/高维前缀和dp）
WQhuanm的博客
03-15 748
sosdp一般是利用前缀和的思想来子集和相关的问题的。
基于网格的聚类算法
02-25
聚类算法很多，包括基于划分的聚类算法（如：kmeans），基于层次的聚类算法（如：BIRCH），基于密度的聚类算法（如：DBScan），基于网格的聚类算法等等。基于划分和层次聚类方法都无法发现非凸面形状的簇，真正能...
DP.rar_dp算法
09-24
算法设计的经典问题，动态规划算法，实现0-1背包问题
dp.rar_dp算法
09-22
介绍动态规划 资料列举了若干应用实例，有分析以及算法实现便于学习
sosdp（高维前缀和）学习笔记
jwg2732的专栏
02-09 1365
高维前缀和 我们先看一维前缀和 for(int i=1;i<=n;i++) s[i]+=s[i-1]; 那么二维前缀和 for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) s[i][j]+=s[i-1][j]+s[i][j-1]-s[i-1][j-1]; 这个是根据容斥计算的，维度很高的时候就不行了 我们换一种方法 for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) s[i][j]+=s[i-1][j]
知识点 - SOS-DP
qq_41848675的博客
09-04 468
知识点 - SOS-DP 解决问题类型： 全称 Sum over Subsets dynamic programmingSum\ over\ Subsets\ dynamic\ programmingSum over Subsets dynamic programming ,子集和dp F[mask]=∑i∈mask...
SoS-DP 学习笔记
终有绿洲摇曳在沙漠
09-02 391
reference: https://codeforces.com/blog/entry/45223 前置技能： 状态压缩 DP SoS-DP 全称是 Sum over Subsets Dynamic Programming，即子集和 DP，属于状态压缩 DP 中的一个经典问题的优化。 1. 问题引入 求 f[s]=∑i∈sa[i]f[s]=\sum\limits_{i\in s} a[i]f...
[算法模板]SOS DP
weixin_30847939的博客
09-17 381
[算法模板]SOS DP 正文 SOS-DP（\(\text{Sum over Subsets}\)）是用来解决这样的问题的： 其实就是子集和DP。上面每个\(F[mask]\)里面包含了\(mask\)所有二进制子集的信息。这是一种\(n\log_2 n\)的DP方法。 我们定义一个DP状态\(S(mask,i)\)代表\(mask\)子集中只有最靠右的\(i\)位与其不同的状态。 ...
CC Killing Monsters 分块+DP(SoS)
noone0的博客
01-21 512
题意:n个怪兽 第i只的血量为h[i].Q次操作,第i次操作为(x,y) 对所有满足i&x=i的下标i 其血量减少y. n0. 给出x  x&i==i的下标i 肯定为x的子集  例如x=011110 i= 0????0 ?可以为0或者1. 子集什么,试一试用SoS 假如下标i二进制表示为 101100  那么对它有伤害的操作其x为 1?11?? i为x的子集 则i为1的位置必须置为1,
SPECIAL PAIRS(Sos_dp)
weixin_43533544的博客
11-25 213
这个是一道救命dp入门题 参考dalao的 >>face<< friendly codes #include <bits/stdc++.h> using namespace std; #define _rep(i, a, b) for (int i = (a); i <= (b); ++i) #define _rev(i, a, b) for (int...
[BZOJ3262] 陌上花开 —— CDQ三维分治
天翼之城的博客
12-09 240
Description 有n朵花,每朵花有三个属性:花形(s)、颜色©、气味(m),用三个整数表示。 现在要对每朵花评级,一朵花的级别是它拥有的美丽能超过的花的数量。 定义一朵花A比另一朵花B要美丽,当且仅Sa&gt;=Sb,Ca&gt;=Cb,Ma&gt;=Mb。 显然,两朵花可能有同样的属性。需要统计出评出每个等级的花的数量。 Input 第一行为N,K (1 &lt;= N &lt;= 10...
SOSdp配套习题
weixin_41665270的博客
08-28 349
SPECIAL PAIRS 题意：给你一个（N<=1e5）的序列，问有多少对（i，j）使得 a[i]&a[j] 为0。 题解：a[i] &a[j]==0表示a[j]在a[i]的补集内，即a[j]⊂\subset⊂(U^a[i])。套套板子就可以了。 Vowels 题意：给你(n<1e4)个长度为3的字符串，仅由‘a’~'x’组成。你要回答‘a’ ~‘x’组成的所有...
Codeforces Round #257 (Div. 1) D - Jzzhu and Numbers 容斥原理 + SOS dp
02-08 121
D - Jzzhu and Numbers 这个容斥没想出来。。。 我好菜啊。。 f[ S ] 表示若干个数 & 的值 & S == S得 方案数， 然后用这个去容斥。 求f[ S ] 需要用SOSdp #include<bits/stdc++.h> #define LL long long #define fi first #define ...
如何通过时间和空间维度衡量算法的质量
06-06
时间和空间维度是评价算法质量的两个重要维度，它们可以帮助我们评估算法的效率和性能。通常，时间维度衡量算法的运行时间，空间维度衡量算法的内存占用。 在时间维度上，我们通常用以下指标来衡量算法的质量： 1....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值