精华内容
下载资源
问答
  • 矩阵中1的最大数(LeetCode)

    千次阅读 2020-08-22 18:46:56
    数值1 在矩阵中的最大数量是多少,现有一个尺寸为sideLength*sideLength 的矩阵M,矩阵中的每个单元格的值不是0就是1,而且知道矩阵 的边长maxOnes,计算矩阵中最多可以有多少个1 参考://...

    数值1 在矩阵中的最大数量是多少,现有一个尺寸为sideLength*sideLength 的矩阵M,矩阵中的每个单元格的值不是0就是1,而且知道矩阵
    的边长maxOnes,计算矩阵中最多可以有多少个1
    参考://https://leetcode.com/savevmk
    根本看不懂

    class Solution(object):
        def maximumNumberOfOnes(self,width: int,height: int, sideLength:int,maxOnes:int) -> int:
            arr = [0 for _ in range(sideLength*sideLength)]
            for i in range(height):
                for j in range(width):
                    row = i%sideLength
                    col = j%sideLength
                    arr[row*sideLength +col]+=1
            arr.sort()# 升序
            ans=0
            for i in range(maxOnes):
                ans += arr[len(arr) -1 -i] # 1的个数
            return ans
    
    if __name__ == '__main__':
        width,height,sideLength,maxOnes = 2,1,4,2
        print(Solution().maximumNumberOfOnes(width,height,sideLength,maxOnes))
    
    展开全文
  • 17:最好的草 查看 ...总时间限制:10000ms单个...它想计算一下牧场中的草丛数量牧场地图中,每个草丛要么单个“#”,要么有公共边的相邻两个“#”。给定牧场地图,计算有多少个草丛。 例如,考虑如...

    17:最好的草

    总时间限制: 
    10000ms
    单个测试点时间限制: 
    1000ms
    内存限制: 
    65536kB
    描述

    奶牛Bessie计划好好享受柔软的春季新草。新草分布在R行C列的牧场里。它想计算一下牧场中的草丛数量。

    在牧场地图中,每个草丛要么是单个“#”,要么是有公共边的相邻两个“#”。给定牧场地图,计算有多少个草丛。

    例如,考虑如下5行6列的牧场地图

    .#....
    ..#...
    ..#..#
    ...##.
    .#....

    这个牧场有5个草丛:一个在第一行,一个在第二列横跨了二、三行,一个在第三行,一个在第四行横跨了四、五列,最后一个在第五行。

     

    输入
    第一行包含两个整数R和C,中间用单个空格隔开。
    接下来R行,每行C个字符,描述牧场地图。字符只有“#”或“.”两种。(1 <= R, C <= 100 )
    输出
    输出一个整数,表示草丛数。
    样例输入
    5 6
    .#....
    ..#...
    ..#..#
    ...##.
    .#....
    
    样例输出
    5


    #include <iostream>
    #include <algorithm>
    #include <stdio.h>
    #include <string>
    #include <ctype.h>
    
    using namespace std;
    char ma[101][101];
    
    int co(int i, int j) {
        if(ma[i+1][j] == '#')   {
            ma[i+1][j] = '.';
            co(i+1, j);
        }
        if(ma[i-1][j] == '#')   {
            ma[i-1][j] = '.';
            co(i-1, j);
        }
        if(ma[i][j+1] == '#')   {
            ma[i][j+1] = '.';
            co(i, j+1);
        }
        if(ma[i][j-1] == '#')   {
            ma[i][j-1] = '.';
            co(i, j-1);
        }
        else{
            return 0;
        }
    }
    
    int main()  {
    
        int a, b;
        scanf("%d%d", &a, &b);
        for(int i = 0; i < a; i++)  {
            for(int j = 0; j < b; j++)  {
                // scanf("%c", &ma[i][j]);
                cin >> ma[i][j];
            }
        }
        int count = 0;
        for(int i = 0; i < a; i++)  {
            for(int j = 0; j < b; j++)  {
                if(ma[i][j] == '#') {
                    co(i, j);
                    count++;
                }
            }
        }
    //    for(int i = 0; i < a; i++)  {
    //        for(int j = 0; j < b; j++)  {
    //            printf("%c", ma[i][j]);
    //        }
    //        printf("\n");
    //    }
        printf("%d\n", count);
    
    
    
        return 0;
    }

    一直对递归有些恐惧,正好用这道题练手

    转载于:https://www.cnblogs.com/QingHuan/p/7113286.html

    展开全文
  • 你可以平面上选择一个任意大的k*k的矩阵,然后矩阵中的每一个格子上放置一定数量的玻璃球,每个格子玻璃球的数量不小于m,这个矩阵中任意的选k个行列均不同的格子,他们包含地玻璃球的数量要都相等的。...

    1.题目链接。题目大意:给定n,m。你可以在平面上选择一个任意大的k*k的矩阵,然后矩阵中的每一个格子上放置一定数量的玻璃球,每个格子玻璃球的数量不小于m,在这个矩阵中任意的选k个行列均不同的格子,他们包含地玻璃球的数量要都是相等的。问有多少种方案。

    2.首先n,m都是大于等于1的,那么我们可以知道,k的最大值就是n,最小值是1,所以首先枚举k。对于每一个固定的k,又该如何解决呢?对于每一个固定的k,由于每个格子放置的数量不小于m,所以任选k个的最小值:k*m,最大值:n。那么我们就可以先写出求和式:

                                                                    ans=\sum_{k=1}^{n}\sum_{T=k*m}^{n}f_m(k,T)

    其中:

                                                                   f_m(k,T)      表示每个格子最少m个,矩阵大小为k,不同行列为T的方案数。那么我们首先简化一下这个式子,如果每个格子至少m个,那么我们把每个格子减去m,也就是每个格子至少0个,这个原问题到转化之后的问题的映射是线性映射,一一对应,所以转化后答案的数量不会变。那么在这种情况下,总和T变为:T-k*m。

    那么原式子变为:

                                                            ans=\sum_{k=1}^{n}\sum_{T=0}^{n-k*m}f_0(k,T-k*m)

    现在着手解决:f0(k,T-k*m).

    问题的现在的表述为,现在有一个k*k的矩阵,我们有多少种方案在矩阵里面填数,填的数字都是大于等于0的数字,使得填完之后这个矩阵不同行列的和都相等,并且和为T(虽然上边是T-k*m,这里简单的写作T)。

    (1)首先考虑怎么样填这个矩阵才能使得选择k个行列不同的格子和都相等?假设矩阵初始值全为0,这个时候满足条件,那么T=1怎么搞?我们考虑任意一行,这一行一定会有一个格子被选中,如果这个格子不是0,是1,那么他就对T有贡献,注意我们考虑该行的格子没有指定考虑哪一个?说明这一行的所有的格子都应该满足这个条件,其实这样就可以显然的得出一个结论:如果要达到任意选行列不同的k个和都相等,那么我们填的时候只能每次操作一整行或者一整列。比如T=1,我们可以任选一行,把这一行的所有格子+1,T=2,我们在T=1的基础上,再任选一行,把这一行的所有格子全部+1.那么问题来了,为什么你只操作行,不操作列?因为这是一个k*k的矩阵,也就是一个方阵,行列的地位都是一样的,或者说二者是等价的。OK,既然这样,我们可以把这个解决方案升级一下,对于总和为T,我们可以这样做:首先任选一行加上a1,任选一列加上b1.....也就是说,我们可以把总和T分割成2*k个元素,他们分别是:a1+a2...ak+b1+b2...bk=T,然后每一个ai,bi,我们任意把他们加到行上或者列上,这样加完之后,得到的矩阵就是满足条件的。那么可能你会有疑问,这样不会使得有的格子数量为0?是的,但是我们已经把问题转化了,转化为每个格子数量大于等于0了。这样问题又转化为:

                                                           \sum_{i=1}^{k}a_i+\sum_{j=1}^{k}b_j=T

    有多少种分割方案,这就是个简单的问题了,相当于:x1+x2+...xn=b有多少种非负整数解的问题,就不再证明这里的结论了,这里不知道的可以参考《组合数学》机械工业出版社的,上面有着严格的证明。那么答案就是:C(2*k+T-1.2*k-1).这里可能有人会有疑问,对于每一组解,我们不还得把他们排列一下,看看到底加到哪一行?这里不用,因为这个解已经包含了所有情况,所以不需要再排列。

    (2)那么上边的就是答案吗?仔细思考一下,有重复的地方。继续这个式子:a1+a2+...ak+b1+b2..bk=T.这里我们让每个a-1,减的1加到b上,那么中和还是不变的。啥意思?如果从最开始的填矩阵的方案考虑,对于每一行,我们让它减一,然后每一列+1,这样对于每个格子,本来行让它-1,但是列又给它+1了,所以每个格子的数量还是不变的,这样我们构造出的矩阵没有任何变,但是这时的,a,b是不同的,我们也把他们计算了一次。产生这种情况的原因是什么呢?究其本质,是ai>=1的时候,都会出现这种情况,并且我们刚才做的变化,也是一个单射,也就是说其实每个a1>=1,他都会被计算两次,第一次是它自己,第二次是它-1列+1.所以我们减去一次才是答案,那么对于所有ai>=1的方案如何计算呢?其实问题又转化为:

                                                     \sum_{i=1}^{k}a_i+\sum_{j=1}^{k}b_j=T(a_i>=1,b_i>=0)

    的方案数: 这个东西其实可以转化为上边的情况,让ai=ai-1,得到的:

                                                  \sum_{i=1}^{k}a_i+\sum_{j=1}^{k}b_j=T-k

    这时候,ai又是非负数,转为为上边的问题:方案数:C(2*k+T-k-1,2*k-1)=C(k+T-1,2*k-1).

    所以答案就是:       C(2*k+T-1,2*k-1)-C(k+T-1,2*k-1).

    到这里,本题已经做完。

    #include<bits/stdc++.h>
    #define ll long long
    using namespace std;
    const int N = 6100;
    ll mod = 998244353;
    ll fac[N], inv[N];
    ll qpow(ll a, ll b) {
    	ll res = 1;
    	while (b)
    	{
    		if (b & 1)res = res *a % mod;
    		a = a * a % mod;
    		b >>= 1;
    	}
    	return res;
    }
    ll C(int n, int m) {
    	if (n < m)
    		return 0;
    	return fac[n] * inv[m] % mod * inv[n - m] % mod;
    }
    void init()
    {
    	fac[0] = inv[0] = 1;
    	for (int i = 1; i < N; i++)
    	{
    		fac[i] = fac[i - 1] * i % mod;
    		inv[i] = qpow(fac[i], mod - 2);
    	}
    }
    int main() {
    	int T;
    	scanf("%d", &T);
    	init();
    	while (T--) {
    		int n, m;
    		ll ans = 0;
    		scanf("%d%d", &n, &m);
    		for (int k = 1; k <= n; k++) {
    			int N = n - m * k;
    			if (N < 0)
    				break;
    			for (int T = 0; T <= N; T++) {
    				ans = (ans + C(2 * k - 1 + T, 2 * k - 1)) % mod;;
    				ans=(ans-C(k - 1 + T, 2 * k - 1)+mod)%mod;
    			}
    		}
    		printf("%lld\n", ans);
    	}
    }
    

     

    展开全文
  • excel使用

    2012-11-25 17:06:01
    (7) 单元格中显示公式如果工作表中的数据多数由公式生成的,想要快速知道每个单元格中的公式形式,以便编辑修改,可以这样做:用鼠标左键单击“工具”菜单,选取“选项”命令,出现“选项”对话框,单击“视图...
  • 如果在矩阵中两两相邻数字被取到话需要付出一定代价。而且给出某些点,规定这些点一定需要取到。求最多可以取到多少点。   大致思路:  怎么说呢,这道题乍看上去和hdoj 1569:方格取数很相似,也很像...
    大致题意:
    
        给出一个n*m的矩阵,让你从中取出一定数量的数字。如果在矩阵中两两相邻的数字被取到的话需要付出一定的代价。而且给出某些点,规定这些点一定需要取到。求最多可以取到多少点。
     
    大致思路:
        怎么说呢,这道题乍看上去和hdoj 1569:方格取数很相似,也很像是一个二分图的最大点权独立集问题。但是问题出的很巧妙,也就没有办法往模版上面套了。把矩阵中的点按照横纵坐标之和的奇偶性分成两个集合,设超级源汇点,源点第一个集合中的所有点连边,容量为这个点代表的数字的值。第二个集合中的所有点向汇点连边,容量也是这个点的值。第一个集合中点都向他周围的点连边,容量为他们同时被取时的消耗。如果一个点必须取,那就将他和源/汇点的容量设为inf,保证这条边不被割掉。用所有点的权值之和sum减去这个图的最小割得到的就是答案。总的来说,ac后的感受就是,这是一道需要意识流的题目
     
    #include<cstdio>
    #include<cstring>
    #include<map>
    #include<vector>
    #include<cmath>
    #include<cstdlib>
    #include<stack>
    #include<queue>
    #include <iomanip>
    #include<iostream>
    #include<algorithm>
    using namespace std ;
    const int N=100001 ;
    const int M=N*5 ;
    const int inf=1<<30 ;
    struct node
    {
    	int u,v,c,next;
    }edge[M];
    int head[N],gap[N],dis[N],cur[N],pre[N];
    int top ;
    
    void add(int u,int v,int c)
    {
    	edge[top].u=u;
    	edge[top].v=v;
    	edge[top].c=c;
    	edge[top].next=head[u];
    	head[u]=top++;
    	edge[top].u=v;
    	edge[top].v=u;
    	edge[top].c=0;
    	edge[top].next=head[v];
    	head[v]=top++; 
    }
    
    int sap(int s,int t,int n)
    {
        
        int flow=0,aug=inf,u;
        memset(dis,0,sizeof(dis));
        memset(gap,0,sizeof(gap));
        for(int i=0; i<=n; i++)          cur[i]=head[i];         
        gap[s]=n;
        u=pre[s]=s;
        while(dis[s]<n)
        {
            
            loop :
            for(int &j=cur[u]; j!=-1; j=edge[j].next)
            {
                int v=edge[j].v;
                if(edge[j].c>0&&dis[u]==dis[v]+1)
                {
                    
                    if(edge[j].c<aug) aug=edge[j].c;
                    pre[v]=u;
                    u=v;
                    if(v==t)     
                    {
                        while(u!=s)
                        {
                           u=pre[u];
                           edge[cur[u]].c-=aug;
                           edge[cur[u]^1].c+=aug;
                       }
                        flow+=aug;
                        aug=inf;
                    }              
                   goto loop ;
                }
            }
            int mindis=n;
            for(int j=head[u]; j!=-1; j=edge[j].next)
            {
                int v=edge[j].v;
                if(edge[j].c>0&&dis[v]<mindis)
                {
                    mindis=dis[v];
                    cur[u]=j;
                }
            }
            if((--gap[dis[u]])==0)
                break;
            gap[dis[u]=mindis+1]++;
            u=pre[u];
        }
        return flow;
    }
    
    int main()
    {
    	int n,m,k,a,b ;
    	int x[100][100];
    	while(~scanf("%d%d%d",&n,&m,&k))
    	{
    		    top=0;
    		    memset(head,-1,sizeof(head));
    		    int s=0,t=n*m+1 ,sum=0;
    		    for(int i=1;i<=n;i++)
    		      for(int j=1;j <=m; j++)
    		       {
    		       	       scanf("%d",&x[i][j]);
    		       	       int tmp=(i-1)*m+j;
    		       	       if((i+j)%2==0)             //连源点汇点 
    		       	       	    add(s,tmp,x[i][j]);
    		       	       else
    		       	           add(tmp,t,x[i][j]);
    		       	         sum += x[i][j];
    		       }
    		     for(int i=1;i<=k;i++)
    			 {
    			 	  scanf("%d%d",&a,&b);
    			 	  int tmp=(a-1)*m+b;
    			 	  if((a+b)%2==0)              //规定的点,容量改为inf,避免被割, 
    		       	        add(s,tmp,inf);
    		       	   else
    		       	        add(tmp,t,inf);		       	       
    			 }  
    		     for(int i=1;i<=n;i++)
    			   for(int j=1;j<=m;j++)
    			    if((i+j)%2==0)
    				{
    			    	   int tmp=(i-1)*m+j;      //相邻损失的分数为 2(a&b); 
    		       	       if(i>1)  add(tmp,tmp-m,2*(x[i][j]&x[i-1][j])) ;  
    		       	       if(i<n)  add(tmp,tmp+m,2*(x[i][j]&x[i+1][j])) ;
    		       	       if(j>1)  add(tmp,tmp-1,2*(x[i][j]&x[i][j-1])) ;
    		       	       if(j<m)  add(tmp,tmp+1,2*(x[i][j]&x[i][j+1])) ;			    	
    			    }  
    			  int ans=sap(s,t,t+1);
    			  printf("%d\n",sum-ans) ;
    	}
    	return 0;
    }
     

     
    展开全文
  • 3.1.14 如何能将两个不同随机场中的两个随机变量联系一起? 140 3.1.15 如果仅有系综图像中的一幅图像,可以计算期望值吗? 142 3.1.16 何时一个随机场相对于均值均匀? 142 3.1.17 何时一个随机场相对于自...
  • HDU 1078 dfs+dp

    2014-09-08 13:48:00
    n*n的矩阵中,每个格子放置了一定数量的食物,一只老鼠每次水平或竖直最多移动k格,每次到位置食物都要比前一次多,问最后一共能得到多少食物 这道题利用记忆化搜索做,利用nowstate不断记录下一个位置所能...
  • LINGO软件学习

    2009-08-08 22:36:50
    LINGO内置的建模语言一种描述性语言,用它可以描述现实世界中的一些问题,然后再借助于LINGO求解器求解。因此,集属性的值一旦模型中被确定,就不可能再更改。LINGO中,只有初始部分中给出的集属性值以后...
  • POJ 1185 炮兵阵地

    2019-10-01 22:37:35
    中文题,大家都说是水题,但是说好的1A呢? 题目大意: 给出n*m的矩阵,当某个单元格有...状态压缩DP,DP[i][j][k]代表当第i行第j种状态时,第i-1行第k种状态时,布置炮兵的最大数量。状态可以预先处理...
  • poj2778

    2014-04-07 16:26:00
    题意:给出字符串长度n(<=2000000000),给出不可以包含...等价态即用fail指针连接点,行走fail指针时匹配字符数量并没有发生变化,因此这些点可以看成相同匹配状态。 通常有两种方法处理等价态,第一...
  • 进行运算的时候,某个位置需要求得丑数一定前面某个丑数乘以2、3或者5的结果,我们分别记录之前乘以2后能得到的最大丑数M2,乘以3后能得到的最大丑数M3,乘以5后能得到的最大丑数M5,那么下一个丑数一定M2,M3...
  • xy坐标系中同一个圆上的所有点的圆方程一样的,它们映射到abr坐标系中的是同一个点,所以abr坐标系中该点就应该有圆的总像素N0个曲线相交。 通过判断abr中每一点的相交(累积)数量,大于一定阈值的点就认为...
  • 实例106 使用指针查找数列中的最大值和最小值 实例107 用指针数组构造字符串数组 实例108 将若干字符串按照字母顺序输出 实例109 用指向函数的指针比较大小 实例110 用指针函数实现求学生成绩 实例111 使用...
  • 实例106 使用指针查找数列中的最大值和最小值 实例107 用指针数组构造字符串数组 实例108 将若干字符串按照字母顺序输出 实例109 用指向函数的指针比较大小 实例110 用指针函数实现求学生成绩 实例111 使用...
  • 参数输入输出上,输入不过多了两个参数:minLineLengh(线的最短长度,比这个短的都被忽略)和MaxLineCap(两条直线之间的最大间隔,小于此值,认为一条直线)。输出上也变了,不再直线参数的,这个函数输出的...
  • 预测错误可能会由这两个分量或者这两个中的任何一个造成。 这里,我们将讨论由方差所造成的有关误差。 岭回归通过收缩参数λ(lambda)解决多重共线性问题。 看下面的公式: 这个公式中,有两个...
  • 实例128 统计某个字符一个字符串变量中的出现次数 实例129 判断字符串中某一字符是否大写 实例130 判断字符串是否为日期或时间 实例131 判断获得字符串中大写字符的个数 实例132 巧截字符串的数字 实例133 ...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    求数组中的最大整数; b. 求n个数的和; c. 利用堆栈类,将本题a和b的代码改成非递归的方式。 实验报告要求: 按要求写出完整的实验代码; <br>实验四 综合(课程设计) 内容及步骤: 1、...
  • 死锁两个或两个以上的进程中的每一个,都等待其中另一个进程释放资源而被封锁,它们都无法向前推进,称这种现象为死锁现象。 产生死锁的原因共享资源有限,多个进程对共享资源的竞争,而且操作不当。 ...
  • 这一讲,我们主要了解一下 Linux 概况,以及对 Linux 有一个初步感性认识。 一.什么Linux? Linux 一个以 Intel 系列 CPU(CYRIX,AMD CPU也可以)为硬件平台,完全免费 UNIX 兼容系统,完全...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    13. 下面程序段带有下划线语句执行次数的数量( ) 【合肥工业大学 2001 三、1(2分)】 i:=n*n WHILE i<>1 DO i:=i div 2; 14. 计算机执行下面语句时,语句 s执行次数为 _______ 。【南京理工大学 ...
  • c语言经典案例

    2014-10-30 08:06:57
    实例117 输出两个数中的最大值 156 实例118 判断素数 157 实例119 递归解决年龄问题 158 实例120 递归解决分鱼问题 159 实例121 小数分离 160 实例122 求任意数的n次幂 161 实例123 固定格式输出当前时间 163 实例...
  • CheckiO 面向初学者和高级程序员编码游戏,使用 Python 和 JavaScript 解决棘手挑战和有趣任务,从而提高你编码技能,本题解系列主要记录自己用 Python 闯关时做题思路和实现代码,同时也学习学习其他...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

在矩阵中的最大数量是多少