精华内容
下载资源
问答
  • 题目链接 ...题解 这道题充分暴露了我的菜。...显然两个局部极小值点不能相邻,所以最多有\(8\)个局部极小值。 然后考虑容斥掉.不能成为局部极小值的限制,那么就变成钦定某些位置一定是局部极小值...

    题目链接

    (bzoj) https://www.lydsy.com/JudgeOnline/problem.php?id=2669
    (luogu) https://www.luogu.org/problem/P3160

    题解

    这道题充分暴露了我的菜。。

    显然两个局部极小值点不能相邻,所以最多有\(8\)个局部极小值。
    然后考虑容斥掉.不能成为局部极小值的限制,那么就变成钦定某些位置一定是局部极小值,其余不限,求方案数。

    然后这个可以状压DP,考虑从小到大加入每个数,然后就很好求了。

    代码

    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cassert>
    #include<iostream>
    #include<vector>
    using namespace std;
    
    const int P = 12345678;
    const int dx[8] = {1,0,-1,0,1,1,-1,-1},dy[8] = {0,1,0,-1,1,-1,-1,1};
    vector<int> kx,ky;
    int bitcnt[(1<<8)+3];
    char a[7][11];
    char b[7][11];
    int num[(1<<8)+3];
    int dp[31][(1<<8)+3];
    int n,m,cnt,ans;
    
    bool check(int x,int y,int typ)
    {
        bool ret = true;
        for(int i=0; i<8; i++)
        {
            int xx = x+dx[i],yy = y+dy[i];
            if(xx>0&&xx<=n&&yy>0&&yy<=m)
            {
                if(typ==0) {if(a[xx][yy]=='X') {return false;}}
                if(typ==1) {if(b[xx][yy]=='X') {return false;}}
            }
        }
        return true;
    }
    
    int calc()
    {
        kx.clear(); ky.clear();
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=m; j++)
            {
                if(a[i][j]=='X') {kx.push_back(i); ky.push_back(j);}
            }
        }
        for(int i=0; i<(1<<kx.size()); i++)
        {
            for(int j=0; j<kx.size(); j++)
            {
                if(!(i&(1<<j))) {b[kx[j]][ky[j]] = 'X';}
            }
            num[i] = 0;
            for(int j=1; j<=n; j++)
            {
                for(int k=1; k<=m; k++)
                {
                    bool ok = check(j,k,1);
                    if((ok && a[j][k]!='X')) num[i]++;
                }
            }
            num[i] += bitcnt[i];
            for(int j=0; j<kx.size(); j++) {b[kx[j]][ky[j]] = '.';}
        }
        dp[0][0] = 1;
        for(int i=0; i<n*m; i++)
        {
            for(int j=0; j<(1<<kx.size()); j++)
            {
                if(dp[i][j])
                {
                    dp[i+1][j] = (dp[i+1][j]+dp[i][j]*(num[j]-i))%P;
                    for(int k=0; k<kx.size(); k++)
                    {
                        if(!(j&(1<<k)))
                        {
                            dp[i+1][j|(1<<k)] = (dp[i+1][j|(1<<k)]+dp[i][j])%P;
                        }
                    }
                }
            }
        }
        int ret = dp[n*m][(1<<kx.size())-1];
        for(int i=0; i<=n*m; i++) for(int j=0; j<(1<<kx.size()); j++) dp[i][j] = 0;
        return ret;
    }
    
    void dfs(int x,int y,int dep)
    {
        if(x==n+1)
        {
            int tmp = calc();
            if((dep-cnt)&1) {ans = ans-tmp<0 ? ans-tmp+P : ans-tmp;}
            else {ans = ans+tmp>=P ? ans+tmp-P : ans+tmp;}
            return;
        }
        int xx = x,yy = y+1; if(yy>m) {yy = 1; xx++;}
        if(a[x][y]=='X')
        {
            bool f = check(x,y,0);
            if(f) {dfs(xx,yy,dep+1);}
        }
        else
        {
            a[x][y] = 'X';
            bool f = check(x,y,0);
            if(f) {dfs(xx,yy,dep+1);}
            a[x][y] = '.';
            dfs(xx,yy,dep);
        }
    }
    
    int main()
    {
        for(int i=1; i<(1<<8); i++) bitcnt[i] = bitcnt[i>>1]+(i&1);
        scanf("%d%d",&n,&m);
        for(int i=1; i<=n; i++) for(int j=1; j<=m; j++) b[i][j] = '.';
        for(int i=1; i<=n; i++) scanf("%s",a[i]+1);
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=m; j++) {if(a[i][j]=='X') cnt++;}
        }
        if(cnt>8) {printf("0"); return 0;}
        dfs(1,1,0);
        printf("%d\n",ans);
        return 0;
    }
    展开全文
  • 针对现有局部模型在分割灰度不均匀图像时容易陷入局部极小值,导致演化曲线停留在背景处或目标内部无法继续演化从而造成分割失败的现象,提出本模型。该模型在能量泛函中增加局部灰度差异项,通过最大化演化曲线上...
  • 学过函数曲线的极小值和最小值的概念吧,局部最佳和全局最佳是类似的关系。 一般训练陷入停滞主要是两方面的原因: 陷入误差曲面凹陷。 神经网络的激活函数是S函数,这个函数的两端是平坦的,算法...

    就是误差曲面局部凹陷点。学过函数曲线的极小值和最小值的概念吧,局部最佳和全局最佳是类似的关系。

    一般训练陷入停滞主要是两方面的原因:

    1. 陷入误差曲面凹陷点。

    2. 神经网络的激活函数是S函数,这个函数的两端是平坦的,算法在这里面走的很慢。

    事实上只要是随机搜索的算法,都会出现这种情况,只是可能性的大小不同罢了。可以使用全局寻优能力强的先行搜索,再用局部搜索能力强的算法继续搜索。

    展开全文
  • bzoj2669-局部极小值

    2019-10-06 16:41:09
    题意 有一个 \(n\times m\) 的矩阵,其中每个数都是 \([1,n\times m]\...一个很关键的信息是局部极小值最多只有8个,以及每个数都不会重复。 这种有大小关系的填数问题,我们可以考虑从小到大填每个数。如果能够...

    题意

    有一个 \(n\times m\) 的矩阵,其中每个数都是 \([1,n\times m]\) 中的一个,不会重复。有一些地方的值比周围的8个位置都小(如果有的话)。给出这些位置,求这样的矩阵有多少个。

    \(n\le 4,m\le 7\)

    分析

    一个很关键的信息是局部极小值的点最多只有8个,以及每个数都不会重复。

    这种有大小关系的填数问题,我们可以考虑从小到大填每个数。如果能够确定当前限制点的填写情况(是否填了),那么我们就能知道当前的决策有多少个可行位置。因为我们是从小到大填每个数,所以每个数的每个位置都是一种方案。

    状态压缩当前限制的填写情况,预处理在一种填写状态下有多少个位置能填,我们就可以通过分当前这个数填在限制位置还是非限制位置进行dp。

    然而会有一些不合法的情况,原因是没有限制的位置我们随便乱填之后可能会出现局部极小值,所以我们要把这些情况减掉。所以使用容斥原理减少限制——保证有某一些为局部极小值,其他不管,进行容斥。我们进行dfs,有哪些位置保证为局部极小值。

    单次dp的复杂度为 \((2^Xnm)\) ,dfs剪枝能够通过。

    代码

    #include<bits/stdc++.h>
    using namespace std;
    typedef long long giant;
    const int xx[]={-1,-1,-1,0,1,1,1,0};
    const int yy[]={-1,0,1,1,1,0,-1,-1};
    const int maxn=5;
    const int maxm=8;
    const int maxx=8;
    const int maxs=1<<maxx;
    const int q=12345678;
    inline int Plus(int x,int y) {return ((giant)x+(giant)y)%q;}
    inline int Multi(int x,int y) {return (giant)x*y%q;}
    int n,m,ans=0,p[maxx][2],cnt[maxs],f[maxn*maxm][maxs],nm,ord=0;
    bool a[maxn][maxm],mp[maxn][maxm];
    inline int nxtx(int x,int y) {return x+(y==m);}
    inline int nxty(int x,int y) {return y==m?1:y+1;}
    void dp() {
        int g=0,s;
        for (int i=1;i<=n;++i) for (int j=1;j<=m;++j) if (a[i][j]) {
            for (int k=0;k<8;++k) {
                int x=i+xx[k],y=j+yy[k];
                if (x>0 && y>0 && x<=n && y<=m && a[x][y]) return;
            }
            p[g][0]=i,p[g][1]=j;
            ++g;
        }
        s=1<<g;
        memset(cnt,0,sizeof cnt);
        for (int j=0;j<s;++j) {
            memset(mp,0,sizeof mp);
            for (int i=0;i<g;++i) if (!((j>>i)&1)) {
                mp[p[i][0]][p[i][1]]|=true;
                for (int k=0;k<8;++k) {
                    int x=p[i][0]+xx[k],y=p[i][1]+yy[k];
                    if (x>0 && y>0 && x<=n && y<=m) mp[x][y]|=true;
                }
            }
            for (int i=1;i<=n;++i) for (int k=1;k<=m;++k) cnt[j]+=(!mp[i][k]);
        }
        memset(f,0,sizeof f);
        f[0][0]=1;
        for (int i=1;i<=nm;++i) for (int j=0;j<s;++j) {
            if (cnt[j]>i-1) f[i][j]=Multi(f[i-1][j],cnt[j]-i+1);
            for (int k=0;k<g;++k) if ((j>>k)&1) f[i][j]=Plus(f[i][j],f[i-1][j^(1<<k)]);
        }
        ans=Plus(ans,(g-ord)&1?q-f[nm][s-1]:f[nm][s-1]);
    }
    void dfs(int x,int y) {
        if (x>n) {
            dp();
            return;
        }
        dfs(n+1,1);
        for (int i=nxtx(x,y),j=nxty(x,y);i<=n;x=i,y=j,i=nxtx(x,y),j=nxty(x,y)) if (!a[i][j]) {
            bool flag=true;
            for (int k=0;k<8;++k) {
                int x=i+xx[k],y=j+yy[k];
                if (x>0 && y>0 && x<=n && y<=m && a[x][y]) {
                    flag=false;
                    break;
                }
            }
            if (!flag) continue;
            a[i][j]=true;
            dfs(i,j);
            a[i][j]=false;
        }
    }
    int main() {
    #ifndef ONLINE_JUDGE
        freopen("test.in","r",stdin);
    #endif
        scanf("%d%d",&n,&m),nm=n*m;
        for (int i=1;i<=n;++i) {
            static char s[maxm+2];
            scanf("%s",s+1);
            for (int j=1;j<=m;++j) if (s[j]=='X') a[i][j]=true,++ord;
        }
        dfs(1,0);
        printf("%d\n",ans);
        return 0;
    }

    转载于:https://www.cnblogs.com/owenyu/p/7373885.html

    展开全文
  • 改进斥力场函数和使用虚拟中间目标法解决传统人工势场法局部极小值问题的MATLAB代码
  • [CQOI2012]局部极小值

    2019-05-29 13:44:00
    不过对于所有的极小值的格子,最多不会超过8个,所以我们状压选了哪些局部极小值的格子(坑儿)。 然后我们从小到大填数,那么对于一个数\(i\),他无非就两种填法:填入一个坑,或是填坑以外的。 填一个坑儿就是...

    嘟嘟嘟

    谁说CQOI的题都是板儿题,我就觉得这题挺难的……

    看到数据范围这么小,就会想状压。然而\(2 ^ {28}\)肯定过不了。不过对于所有的极小值的格子,最多不会超过8个,所以我们状压选了哪些局部极小值的格子(坑儿)。

    然后我们从小到大填数,那么对于一个数\(i\),他无非就两种填法:填入一个坑,或是填坑以外的点。
    填一个坑儿就是直接填,于是有\(dp[i][S] = \sum dp[i - 1][S\) ^ \((1 << k)]\)
    不填坑的话,得考虑填上这个数之后,那些还没有填的坑仍能保证是坑,即不能往他们的四周填。因此我们预处理出来对于当前每一个状态,可以填的格子数目\(num[S]\)。然后有转移方程\(dp[i][S] = dp[i - 1][S] * (num[S] - (i - 1))\)
    答案就是\(dp[n * m][(1 << tot) - 1]\)\(tot\)是坑的总数。

    但光这样是不对的。因为一些不是坑的点填完后可能成为了坑,换句话说,我们上面的\(dp[n * m][(1 << tot) -1]\)表示的是至少有\(tot\)个坑时的方案数,而我么需要的是恰好有这么多坑的方案数。
    那么就能想到容斥了!我们暴力枚举棋盘上哪些格子可以是坑,然后每构造一个棋盘,就dp一次,然后看看是加上还是减去。

    #include<cstdio>
    #include<iostream>
    #include<cmath>
    #include<algorithm>
    #include<cstring>
    #include<cstdlib>
    #include<cctype>
    #include<vector>
    #include<stack>
    #include<queue>
    #include<assert.h>
    using namespace std;
    #define enter puts("") 
    #define space putchar(' ')
    #define Mem(a, x) memset(a, x, sizeof(a))
    #define In inline
    typedef long long ll;
    typedef double db;
    const int INF = 0x3f3f3f3f;
    const db eps = 1e-8;
    const ll mod = 12345678;
    In ll read()
    {
      ll ans = 0;
      char ch = getchar(), last = ' ';
      while(!isdigit(ch)) last = ch, ch = getchar();
      while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
      if(last == '-') ans = -ans;
      return ans;
    }
    In void write(ll x)
    {
      if(x < 0) x = -x, putchar('-');
      if(x >= 10) write(x / 10);
      putchar(x % 10 + '0');
    }
    In void MYFILE()
    {
    #ifndef mrclr
      freopen(".in", "r", stdin);
      freopen(".out", "w", stdout);
    #endif
    }
    
    int n, m, TOT;
    char s[5][8];
    ll ans = 0;
    
    In ll inc(ll a, ll b) {return a + b < mod ? a + b : a + b - mod;}
    
    struct Node
    {
      int x, y;
    }t[30];
    int tot = 0, num[(1 << 8) + 5];
    bool vis[5][8];
    ll dp[30][(1 << 8) + 5];
    const int dx[] = {-1, -1, 0, 1, 1, 1, 0, -1}, dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
    In void calc()
    {
      tot = 0;
      for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j)
          if(s[i][j] == 'X') t[++tot] = (Node){i, j};
      for(int i = 0; i < (1 << tot); ++i)
        {
          Mem(vis, 0);
          for(int j = 1; j <= tot; ++j)
        if(!((i >> (j - 1)) & 1))
          {
            vis[t[j].x][t[j].y] = 1;
            for(int k = 0; k < 8; ++k)
              {
            int nx = t[j].x + dx[k], ny = t[j].y + dy[k];
            if(nx && nx <= n && ny && ny <= m) vis[nx][ny] = 1;
              }
          }
          int cnt = 0;
          for(int j = 1; j <= n; ++j)
        for(int k = 1; k <= m; ++k) cnt += vis[j][k];
          num[i] = n * m - cnt;
        }
      Mem(dp, 0); dp[0][0] = 1;
      for(int i = 1; i <= n * m; ++i)
        {
          for(int S = 0; S < (1 << tot); ++S)
        {
          dp[i][S] = inc(dp[i][S], dp[i - 1][S] * (num[S] - i + 1) % mod);
          for(int j = 0; j < tot; ++j)
            if((S >> j) & 1) dp[i][S] = inc(dp[i][S], dp[i - 1][S ^ (1 << j)]);
        }
        }
      ll tp = dp[n * m][(1 << tot) - 1];
      ans = inc(ans, ((tot - TOT) & 1) ? mod - tp: tp);
    }
    
    In void dfs(int x, int y)
    {
      if(x == n + 1) {calc(); return;}
      if(y == m) dfs(x + 1, 1);
      else dfs(x, y + 1);
      if(s[x][y] == 'X') return;
      bool flg = 1;
      for(int i = 0; i < 8 && flg; ++i)
        {
          int nx = x + dx[i], ny = y + dy[i];
          if(nx && nx <= n && ny && ny <= m)
        if(s[nx][ny] == 'X') flg = 0;
        }
      if(!flg) return;
      s[x][y] = 'X';
      if(y == m) dfs(x + 1, 1);
      else dfs(x, y + 1);
      s[x][y] = '.';
    }
    
    int main()
    {
      //MYFILE();
      n = read(), m = read();
      for(int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
      for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j) TOT += (s[i][j] == 'X');
      dfs(1, 1);
      write(ans), enter;
      return 0;
    }

    转载于:https://www.cnblogs.com/mrclr/p/10943389.html

    展开全文
  • 要求: 编程实现:1.成功失败法找到存在局部...在该区间内用0.618法找到局部极小值点,精确度为0.01  测试函数为:函数f(x)=x^4+x^3-x^2+1;   成功失败法找到区间[a,b]:  1.取x,步长l>0,令k=0,若f(x+l)  
  • P3160 [CQOI2012]局部极小值 双倍经验,双倍快乐 解题思路 存下来每个坑(极小值点)的位置,以这个序号进行状态压缩。 显然,\(4*7\)的数据范围让极小值点在8个以内(以下示意) X . X . X . X . . . . . . . . . ...
  • 二话不说先观察一下性质,首先棋盘很窄,可以乱搞的样子,然后注意到如果一个局部极小值那么周围3*3矩阵内不能有另一个局部最小值。于是画个图发现题目的数据范围最多有8个局部最小值。性质大概就是这些了。 暴...
  • 下面内容摘自西瓜书,也是我的...这相当于从不同的初始开始搜索,这样就可能陷入不同的局部极小,从中进行选择有可能更接近全局最小的结果。 2. 使用 ”模拟退火“ 技术,模拟退火在每一步都以一定的概率接受比当...
  • 【CQOI2012】局部极小值

    千次阅读 2016-08-15 22:25:57
    因为要求有X的比周围的点小,那么可以把数从小到大填。 设f[i][j]表示数值已经填到了第i个数,X填的状态为j。 转移方程:f[i][j]=∑k∈jf[i−1][j−k]+max(0,rest[j]−i+1)∗f[i−1][j]f[i][j]=\sum_{
  • 一个局部最小值就可以覆盖最少四个(放在四个角上),最多九个(放在中间) 所以最多只会有8个局部最小值,可以考虑一下状压 我们可以考虑从小到大地放入每个元素 dp[i][j]表示在选择的局部最小值状态为j时,...
  • 这相 当于从多个不同的初始开始搜索, 这样就可能陷入不同的局部极小从中进行选择有可能获得更接近全局最小的结果。 2.使用 "模拟退火" (simulated annealing) 技术 [Aarts and Korst, 1989]. 模拟退火在每一步...
  • 考虑对于'X'的不会超过8个,用二进制表示 f[i][j]表示当前填了第i个数字,状态为j的方案数 由到大填 f[i+1][j]=f[i][j]*num[j] num表示当前这个状态,有多少位置可以填。为了保证合法,没被填的'X'周围的格子...
  • 可以发现一个 \(4\times 7\) 的矩阵中,有局部最小值的最多有 \(2\times 4 = 8\) 个,所以我们可以状压一下每个局部最小值的位置有没有被选。 从小到大填入每一个格子,那么如果一个的周围有没有被填上的局部...
  • 假设我有一个numpy数组,其中包含对连续可微函数的计算,我想找到局部极小值。没有噪音,所以每一个值低于所有相邻的值的都符合我对局部最小值的标准。我有以下列表理解,它适用于二维数组,忽略边界上的潜在极...
  • 全局最小与局部极小

    千次阅读 2018-06-10 21:11:09
    首先,学过高等数学的人肯定都知道最小值与极小值,此处我们可以将全局最小理解为最小值,局部极小理解为极小值,梯度对应三维空间我们可以理解为在某一点斜度的,我们寻找局部极小,首先选择某些出发,然后沿着负...
  • 回忆一下关于元实函数的的求导问题,函数的一阶导数为 函数的梯度正好是导数的转置,即...对于向量,和约束集中的某个,如果存在一个实数使得对于所有,仍然在约束集内,即,则称为处的可行方向!为元实函数...
  • 局部极小

    2012-11-12 09:32:59
    神经网络在作为一种搜索策略的时候,受搜索算法的控制,当解空间函数存在局部最小值时,如果搜索步长较小(动量较小),那么有可能在这个局部求解时求得的所有解都指向了极小值的方法,就是陷入的局部最小。...
  • Hessian矩阵及局部极小点的条件

    千次阅读 2018-07-25 11:02:22
    函数f(x)相对于n×1n×1n\times 1实向量x的二阶偏导是一个由m2m2m^2个二阶偏导组成的矩阵(称为Hessian矩阵),定义为: ∂2f(x)∂x∂xT=∂∂xT[∂f(x)∂x]∂2f(x)∂x∂xT=∂∂xT[∂f(x)∂x]{\partial ^2f(x)\...
  • 回忆一下关于元实函数的的求导问题,函数的一阶导数为 函数的梯度正好是导数的转置,即;函数的二阶导数,也称为hessian矩阵,可表示为: ...
  • 注意:由于这里求的是极大值,而用梯度下降法得到的是极小值,因此将原函数取负值,最后得到结果时再取相反数 这个代码中还存在问题,由于用了matlab中自带的subs()函数,因此相关变量的都变成了sym类型,因此无法...
  • 梯度法 众所周知,基于梯度的搜索是使用最为广泛的参数寻优方法。...若误差函数在当前的梯度为零,则已达到局部最小,更新量为零,参数的迭代更新停止。 缺陷:当误差函数具有多个局部最小,...
  • 针对网孔织物图像的对比度低和噪声多而导致分割结果中存在网孔连在一起和残缺等问题,提出一种基于区域灰度极小值的分割算法以期提高网孔的分割精度。首先利用高斯金字塔缩放和直方图均衡化算法处理图像以增强图像...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 383
精华内容 153
关键字:

局部极小值点