2022-12-26：有一个数组包含0、1、2三种值，
有m次修改机会，第一种将所有连通的1变为0，修改次数-1，
第二种将所有连通的2变为1或0，修改次数-2，
返回m次修改机会的情况下，让最大的0连通区，最长能是多少？
1 <= arr长度 <= 10^6，
0 <= 修改机会 <= 10^6。

答案2022-12-26：

六个辅助数组。
时间复杂度：O(N)。

代码用shell编写。代码如下：

  1. #!/bin/bash
  3. # 时间复杂度O(N^3)的方法
  4. # 为了验证
  5. # public static int maxZero1(int[] arr, int k)
  6. function maxZero1(){
  7.     eval local arrt=\$$1
  8.     local arr=(`echo $arrt | tr ',' ' '`)
  9.     local k=$2
  11.     local n=${#arr[*]}
  12.     local ans=0
  14.     local i=0
  15.     while [ $i -lt $n ]
  16.     do
  17.         let local j=n-1
  18.         while [ $j -ge $i ]
  19.         do
  20.             local t=$(cost1 arrt $i $j)
  21.             if [ $t -le $k ];then
  22.                 ans=$(get_max $ans $[$j-$i+1])
  23.                 break
  24.             fi
  25.             let j--
  26.         done
  27.         let i++
  28.     done
  29.     echo $ans
  30. }
  32. # 为了验证
  33. # public static int cost1(int[] arr, int l, int r)
  34. function cost1() {
  35.     eval local arrt=\$$1
  36.     local arr=(`echo $arrt | tr ',' ' '`)
  37.     local l=$2
  38.     local r=$3
  40. 	local num0=0
  41. 	local num2=0
  42. 	let local n=r-l+1
  44.     local i=$l
  45.     while [ $i -le $r ]
  46.     do
  47.         if [ ${arr[$i]} == 0 ];then
  48.             let num0++
  49.         fi
  50.         if [ ${arr[$i]} == 2 ];then
  51.             let num2++
  52.         fi
  53.         let i++
  54.     done
  56.     if [ $num0 == $n ];then
  57.         echo -n 0
  58.         return 0
  59.     fi
  60.     if [ $num2 == $n ];then
  61.         echo -n 2
  62.         return 0
  63.     fi
  64.     local area2=0
  65.     if [ ${arr[$l]} == 2 ];then
  66.         area2=1
  67.     fi
  69.     local i=$l
  70.     while [ $i -lt $r ]
  71.     do
  72.         if [ ${arr[$i]} != 2 ] && [ ${arr[$[$i+1]]} == 2 ];then
  73.             let area2++
  74.         fi
  75.         let i++
  76.     done
  78. 	local has1=0
  79. 	local areaHas1No0=0
  81.     local i=$l
  82.     while [ $i -le $r ]
  83.     do
  84.         if [ ${arr[$i]} == 0 ];then
  85.             if [ $has1 == 1 ];then
  86.                 let areaHas1No0++
  87.             fi
  88.             has1=0
  89.         fi
  90.         if [ ${arr[$i]} == 1 ];then
  91.             has1=1
  92.         fi
  93.         let i++
  94.     done
  96.     if [ $has1 == 1 ];then
  97.         let areaHas1No0++
  98.     fi
  100.     let local ans=2*$area2+areaHas1No0
  101.     echo -n $ans
  102.     return 0
  103. }
  105. function get_max()
  106. {
  107.     if [ $1 -gt $2 ];then
  108.         echo -n $1
  109.     else
  110.         echo -n $2
  111.     fi
  112. }
  114. # 正式方法
  115. # 时间复杂度O(N)
  116. left10=()
  117. left2x=()
  118. right10=()
  119. right2x=()
  120. area2s=()
  121. area1s=()
  123. for i in {0..1000000}
  124. do
  125.     left10[$i]=0
  126.     left2x[$i]=0
  127.     right10[$i]=0
  128.     right2x[$i]=0
  129.     area2s[$i]=0
  130.     area1s[$i]=0
  131. done
  133. # public static int maxZero2(int[] arr, int k)
  134. function maxZero2() {
  135.     eval local arrt=\$$1
  136.     local arr=(`echo $arrt | tr ',' ' '`)
  137.     local k=$2
  139.     local n=${#arr[*]}
  140.     local last=-1
  142.     local i=0
  143.     while [ $i -lt $n ]
  144.     do
  145.         if [ ${arr[$i]} == 0 ];then
  146.             let last=i
  147.         fi
  148.         if [ ${arr[$i]} == 1 ];then
  149.             let left10[i]=last
  150.         fi
  151.         let i++
  152.     done
  154.     let last=-1
  156.     local i=0
  157.     while [ $i -lt $n ]
  158.     do
  159.         if [ ${arr[$i]} != 2 ];then
  160.             let last=i
  161.         fi
  162.         if [ ${arr[$i]} == 2 ];then
  163.             let left2x[i]=last
  164.         fi
  165.         let i++
  166.     done
  168.     let last=n
  170.     let i=n-1
  171.     while [ $i -ge 0 ]
  172.     do
  173.         if [ ${arr[$i]} == 0 ];then
  174.             let last=i
  175.         fi
  176.         if [ ${arr[$i]} == 1 ];then
  177.             let right10[i]=last
  178.         fi
  179.         let i--
  180.     done
  182.     let last=n
  184.     let i=n-1
  185.     while [ $i -ge 0 ]
  186.     do
  187.         if [ ${arr[$i]} != 2 ];then
  188.             let last=i
  189.         fi
  190.         if [ ${arr[$i]} == 2 ];then
  191.             let right2x[i]=last
  192.         fi
  193.         let i--
  194.     done
  196.     local area2=0
  197.     if [ ${arr[0]} == 2 ];then
  198.         let area2=1
  199.     fi
  201.     local i=0
  202.     while [ $i -lt $[$n-1] ]
  203.     do
  204.         if [ ${arr[$i]} != 2 ];then
  205.             let area2s[i]=area2
  206.             if [ ${arr[$[$i+1]]} == 2 ];then
  207.                 let area2++
  208.             fi
  209.         fi
  210.         let i++
  211.     done
  213.     # let local t=n-1
  214.     if [ ${arr[$[$n-1]]} != 2 ];then
  215.         let area2s[$[$n-1]]=area2
  216.     fi
  218.     local has1=0
  219.     local area1=0
  221.     local i=0
  222.     while [ $i -lt $n ]
  223.     do
  224.         if [ ${arr[$i]} == 0 ];then
  225.             if [ $has1 == 1 ];then
  226.                 let area1++
  227.             fi
  228.             let has1=0
  229.             let area1s[i]=area1
  230.         fi
  231.         if [ ${arr[$i]} == 1 ];then
  232.             let has1=1
  233.         fi
  234.         let i++
  235.     done
  237.     local ans=0
  238.     local right=0
  240.     local left=0
  241.     while [ $left -lt $n ]
  242.     do
  243.         while [ $right -lt $n ] && [ $(cost2 arrt $left $right) -le $k ]
  244.         do
  245.             let right++
  246.         done
  248.         let local t=right-left
  249.         ans=$(get_max $ans $t)
  250.         let t=left+1
  251.         right=$(get_max $right $t)
  252.         let left++
  253.     done
  254.     echo -n $ans
  255.   	return 0
  256. }
  258. # public static int cost2(int[] arr, int left, int right)
  259. function cost2() {
  260.     eval local arrt=\$$1
  261.     local arr=(`echo $arrt | tr ',' ' '`)
  262.     local left=$2
  263.     local right=$3
  265.     if [ ${arr[$left]} == 2 ] && [ ${right2x[$left]} -gt $right ];then
  266.         echo -n 2
  267.         return 0
  268.     fi
  270.     local area2=0
  271.     if [ ${arr[$left]} == 2 ];then
  272.         let area2=1
  273.     fi
  274.     if [ ${arr[$right]} == 2 ];then
  275.         let area2++
  276.     fi
  278.     if [ ${arr[$left]} == 2 ];then
  279.         let left=right2x[left]
  280.     fi
  281.     if [ ${arr[$right]} == 2 ];then
  282.         let right=left2x[right]
  283.     fi
  284.     let area2+=area2s[right]-area2s[left]
  285.     local area1=0
  287.     if [ ${arr[$left]} == 0 ] && [ ${arr[$right]} == 0 ];then
  288.         let area1=area1s[right]-area1s[left]
  289.     elif [ ${arr[$left]} == 0 ];then
  290.         let area1++
  291.         let right=left10[right]
  292.         let area1+=area1s[right]-area1s[left]
  293.     elif [ ${arr[$right]} == 0 ];then
  294.         let area1++
  295.         let left=right10[left]
  296.         let area1+=area1s[right]-area1s[left]
  297.     else
  298.         if [ ${right10[$left]} -gt $right ];then
  299.             let area1++
  300.         else
  301.   			let area1+=2
  302.   			let left=right10[left];
  303.   			let right=left10[right];
  304.   			let area1+=area1s[right]-area1s[left];
  305.         fi
  306.     fi
  307.     let local ans=2*area2+area1
  308.     echo -n $ans
  309.   	return 0
  310. }
  312. # public static int[] randomArray(int n)
  313. function random_array()
  314. {
  315.     local n=$1
  316.     local ans=()
  317.     local i=0
  318.     while [ $i -lt $n ]
  319.     do
  320.         let ans[$i]=$RANDOM%3
  321.         let i++
  322.     done
  323.     echo -n ${ans[*]}
  324.     return 0
  325. }
  327. # public static void main(String[] args)
  328. function main()
  329. {
  330.     local n=5
  331.     local testTimes=5
  332.     printf "测试开始\r\n"
  333.     local i=1
  334.     while [ $i -le $testTimes ]
  335.     do
  336.         local arrt=$(random_array $n)
  337.         local k=1
  338.         printf "arrt=$arrt,k=$k\r\n"
  339.         local arr=(`echo $arrt | tr ',' ' '`)
  340.         local ans1=$(maxZero1 arrt $k)
  341.         local ans2=$(maxZero2 arrt $k)
  342.         if [ $ans1 != $ans2 ]
  343.         then
  344.             printf "错误ans1 = %s\r\n" $ans1
  345.             printf "错误ans2 = %s\r\n" $ans2
  346.             break
  347.         fi
  348.         printf "==ans = %s\r\n" $ans1
  349.         printf "$i end===============\r\n"
  350.         i=$[$i+1]
  351.     done
  352.     printf "测试结束\r\n"
  353. }
  355. main

贪心验证如下：

  1. #!/bin/bash
  3. I32MAX=2147483647
  5. # public static int getMin(int a, int b)
  6. function get_min()
  7. {
  8.     if [ $1 -lt $2 ];then
  9.         echo $1
  10.     else
  11.         echo $2
  12.     fi
  13. }
  15. # public static int best1(int[] arr)
  16. function best1()
  17. {
  18.     eval local arrt=\$$1
  19.     local arr=(`echo $arrt | tr ',' ' '`)
  21.     local zero=0
  22.     local two=0
  23.     local n=${#arr[*]}
  24.     local i=0
  25.     while [ $i -lt $n ]
  26.     do
  27.         if [ ${arr[$i]} == 0 ];then
  28.             let zero++
  29.         fi
  30.         if [ ${arr[$i]} == 2 ];then
  31.             let two++
  32.         fi
  33.         let i++
  34.     done
  35.     if [ $zero == $n ];then
  36.         echo -n 0
  37.         return 0
  38.     fi
  39.     if [ $two == $n ];then
  40.         echo -n 2
  41.         return 0
  42.     fi
  43.     local ans=$I32MAX
  44.     local i=0
  45.     while [ $i -lt $n ]
  46.     do
  47.         if [ ${arr[$i]} != 0 ] && ([ $i == 0 ] || [ ${arr[$[$i-1]]} != ${arr[$i]} ])
  48.         then
  49.             if [ ${arr[$i]} == 2 ]
  50.             then
  51.                 local temp1=$(change arrt $i 1)
  52.                 temp1a=$(best1 temp1)
  54.                 local temp0=$(change arrt $i 0)
  55.                 temp0a=(`echo -n $temp0 | tr ',' ' '`)
  56.                 temp0a=$(best1 temp0)
  58.                 local temp=$(get_min $temp1a $temp0a)
  59.                 let temp=temp+2
  60.                 ans=$(get_min $ans $temp)
  61.             else
  62.                 local temp=$(change arrt $i 0)
  63.                 local tempa=(`echo -n $temp | tr ',' ' '`)
  64.                 temp=$(best1 temp)
  65.                 let temp++
  66.                 ans=$(get_min $ans $temp)
  67.             fi
  68.         fi
  69.         let i++
  70.     done
  71.     echo -n $ans
  72.     return 0
  73. }
  75. # public static int[] change(int[] arr, int i, int to)
  76. function change()
  77. {
  78.     eval local arr=\$$1
  79.     arr=(`echo $arr | tr ',' ' '`)
  80.     local i=$2
  81.     local to=$3
  83.     local l=$i
  84.     local r=$i
  85.     while [ $l -ge 0 ] && [ ${arr[$l]} == ${arr[$i]} ]
  86.     do
  87.         let l--
  88.     done
  89.     while [ $r -lt ${#arr[*]} ] && [ ${arr[$r]} == ${arr[$i]} ]
  90.     do
  91.         let r++
  92.     done
  94.     local ans=()
  95.     i=0
  96.     while [ $i -lt ${#arr[*]} ]
  97.     do
  98.         let ans[i]=arr[i]
  99.         let i++
  100.     done
  102.     let i=l+1
  103.     while [ $i -lt $r ]
  104.     do
  105.         let ans[i]=to
  106.         let i++
  107.     done
  109.     # 返回ans
  110.     echo -n ${ans[*]}
  111. }
  113. # public static int cost(int[] arr, int l, int r)
  114. function cost()
  115. {
  116.     eval local arr=\$$1
  117.     local arr=(`echo $arr | tr ',' ' '`)
  118.     local l=$2
  119.     local r=$3
  121.     local num0=0
  122.     local num2=0
  123.     let local n=r-l+1
  124.     let local i=l
  125.     while [ $i -le $r ]
  126.     do
  127.         if [ ${arr[$i]} == 0 ];then
  128.             let num0++
  129.         fi
  130.         if [ ${arr[$i]} == 2 ];then
  131.             let num2++
  132.         fi
  133.         let i++
  134.     done
  135.     if [ $num0 == $n ];then
  136.         echo -n 0
  137.         return 0
  138.     fi
  139.     if [ $num2 == $n ];then
  140.         echo -n 2
  141.         return 0
  142.     fi
  144.     local area2=0
  145.     if [ ${arr[$l]} == 2 ];then
  146.         let area2=1
  147.     fi
  149.     local i=$l
  150.     while [ $i -lt $r ]
  151.     do
  152.         local j=i+1
  153.         if [ ${arr[$i]} != 2 ] && [ ${arr[$j]} == 2 ]
  154.         then
  155.             let area2++
  156.         fi
  157.         let i++
  158.     done
  160.     local has1=0
  161.     local areaHas1No0=0
  162.     i=$l
  163.     while [ $i -le $r ]
  164.     do
  165.         if [ ${arr[$i]} == 0 ];then
  166.             if [ $has1 == 1 ];then
  167.                 let areaHas1No0++
  168.             fi
  169.             has1=0
  170.         fi
  171.         if [ ${arr[$i]} == 1 ];then
  172.             let has1=1
  173.         fi
  174.         let i++
  175.     done
  176.     if [ $has1 == 1 ];then
  177.         let areaHas1No0++
  178.     fi
  179.     let local ans=2*$area2+areaHas1No0
  180.     echo -n $ans
  181.     return 0
  182. }
  184. # public static int[] randomArray(int n)
  185. function random_array()
  186. {
  187.     local n=$1
  188.     local ans=()
  189.     local i=0
  190.     while [ $i -lt $n ]
  191.     do
  192.         let ans[$i]=$RANDOM%3
  193.         let i++
  194.     done
  195.     echo -n ${ans[*]}
  196.     return 0
  197. }
  199. # public static void main(String[] args)
  200. function main()
  201. {
  202.     local n=5
  203.     local testTimes=5
  204.     printf "测试开始\r\n"
  205.     local i=0
  206.     while [ $i -lt $testTimes ]
  207.     do
  208.         local arr=$(random_array $n)
  209.         printf "arr=$arr\r\n"
  210.         local arrt=(`echo $arr | tr ',' ' '`)
  211.         local ans1=$(best1 arr)
  212.         local ans2=$(cost arr 0 $[${#arrt[*]}-1])
  213.         if [ $ans1 != $ans2 ]
  214.         then
  215.             printf "错误ans1 = %s\r\n" $ans1
  216.             printf "错误ans2 = %s\r\n" $ans2
  217.             break
  218.         fi
  219.         printf "==ans1 = %s\r\n" $ans1
  220.         printf "==ans2 = %s\r\n" $ans2
  221.         printf "$i end===============\r\n"
  222.         i=$[$i+1]
  223.     done
  224.     printf "测试结束\r\n"
  225. }
  227. main
  229. # public static void main(String[] args)
  230. function main1()
  231. {
  232.     local n=5
  233.     local testTimes=1
  234.     printf "测试开始\r\n"
  235.     local i=0
  236.     while [ $i -lt $testTimes ]
  237.     do
  238.         local arr=$(random_array $n)
  239.         printf "main arr = $arr\r\n"
  240.         local arrt=(`echo $arr | tr ',' ' '`)
  241.         local ans2=$(cost arr 0 $[${#arrt[*]}-1])
  242.         printf "ans2 = %s\r\n" $ans2
  243.         printf "end===============\r\n"
  244.         i=$[$i+1]
  245.     done
  246.     printf "测试结束\r\n"
  247. }

2022-12-26：有一个数组包含0、1、2三种值， 有m次修改机会，第一种将所有连通的1变为0，修改次数-1， 第二种将所有连通的2变为1或0，修改次数-2， 返回m次修改机会的情况下，让最大的0的更多相关文章

  1. 混合模式程序集是针对“v1.1.4322”版的执行时生成的,在没有配置其它信息的情况下,无法在 4.0 执行时中载入该程序集。

    看到一个kinect大牛编写的一个水果忍者的体感游戏版本号,让我为自己一直以来仅仅用现有的网页游戏来模拟kinect体感游戏控制感到羞愧,没办法.我还是菜鸟.学习一段后自己模仿星际大战这个游戏.自己写 ...

  2. 一个数组nums，其中任意两个值等于给定值target，返回这两个值在nums里的位置

    package com.java.tencent; import java.lang.reflect.Array; import java.util.Arrays; import java.util. ...

  3. 9、Cocos2dx 3.0游戏开发三查找值小工厂方法模式和对象

    重开发人员的劳动成果,转载的时候请务必注明出处:http://blog.csdn.net/haomengzhu/article/details/27704153 工厂方法模式 工厂方法是程序设计中一个 ...

  4. 七、如何在Java中高效检查一个数组是否含有一个值

    如何检查一个数组(非排序的)是否包含特定的值.这是个非常有用或经常被在Java中使用.这是个在Stack Overflow中高得票的问题.在已经高得票的答案中,有许多不同的处理方法,但是时间的复杂度非 ...

  5. Java 高效检查一个数组中是否包含某个值

    如何检查一个数组(未排序)中是否包含某个特定的值?在Java中,这是一个非常有用并又很常用的操作.同时,在StackOverflow中,有时一个得票非常高的问题.在得票比较高的几个回答中,时间复杂度差 ...

  6. 给定一个只包含正整数的非空数组,返回该数组中重复次数最多的前N个数字 ,返回的结果按重复次数从多到少降序排列(N不存在取值非法的情况)

    """ #给定一个只包含正整数的非空数组,返回该数组中重复次数最多的前N个数字 #返回的结果按重复次数从多到少降序排列(N不存在取值非法的情况) 解题思路: 1.设定一个 ...

  7. 算法题——给定一个数组 arr，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

    参考自:https://blog.csdn.net/qq_38200548/article/details/80688630 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] ...

  8. Log4j 2使用教程 分类： B1_JAVA 2014-07-01 12:26 314人阅读 评论(0) 收藏

    转载自 Blog of 天外的星星: http://www.cnblogs.com/leo-lsw/p/log4j2tutorial.html Log4j 2的好处就不和大家说了,如果你搜了2,说明你 ...

  9. 编写一个方法，输入DOM节点，返回包含所有父节点的一个数组

    编写一个方法,输入DOM节点,返回包含所有父节点的一个数组 function getParentsNodes(element) { var parents = []; var getParentsNo ...

  10. 包含MIN函数的栈+一个数组实现两个堆栈+两个数组实现MIN栈

    1.题目描述 定义栈的数据结构,请在该类型中实现一个能够得到栈最小元素的min函数. 思路:利用一个辅助栈来存放最小值     栈  3,4,2,5,1     辅助栈 3,2,1 每入栈一次,就与辅 ...

随机推荐

  1. 基于Rocky Linux搭建Windows域控制器

    1.基于Rocky Linux搭建Windows域控制器 https://blog.csdn.net/Sakura0156/article/details/125822938?spm=1001.210 ...

  2. 截取屏幕 转为GIF 图片

    近期winform 做的一个截取屏幕的软件给大家!谁要留言给我哦! sss

  3. msfvenom的使用

    msfvenom也只metasploit中的一个很强的工具,msfvenom生成木马非常的迅速可以各种版本的木马 该工具由msfpaylod和msfencodes的组成 生成木马是需要在本地监听,等待 ...

  4. 【分布式技术专题】「分布式技术架构」一文带你厘清分布式事务协议及分布式一致性协议的算法原理和核心流程机制（Paxos篇）

    概念简介 Paxos是一种基于消息传递具有高度容错特性的一致性算法,是目前公认的解决分布式一致性问题最有效的算法之一. 发展历史 Paxos算法的发展历史追溯到古希腊,当时有一个名为"Pax ...

  5. linux中查看用户和组信息小结

    查看当前登录用户的组内成员groups 查看当前登录用户名whoami 查看tom用户所在的组,以及组内成员groups tom 查看所有的用户信息cat /etc/passwd 用户名.密码.用户i ...

  6. 分库分表ShardingJDBC最佳实践

    1 添加依赖 <dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId> ...

  7. dart基础---->函数传值

    1. string type main(List<String> args) { String name = "huhx"; changIt(name); print( ...

  8. MarkdownStudy03JDK

    卸载JDK 删除jdk文件夹 删除配置环境(计算机>属性>高级>系统变量中的JAVA_HOME和Path) 删除JAVA_HOME环境变量 删除path环境变量 用dos窗口查看是否 ...

  9. API网关：开源Apinto网关快速入门

    Apinto网关基于GO语言模块化开发,5分钟极速部署,配置简单.易于维护,支持集群与动态扩容,开箱即用.Apinto除了提供丰富的网关插件外,还提供监控告警.用户角色等扩展应用,同时支持自定义网关插 ...

  10. 驱动开发：探索DRIVER_OBJECT驱动对象

    本章将探索驱动程序开发的基础部分,了解驱动对象DRIVER_OBJECT结构体的定义,一般来说驱动程序DriverEntry入口处都会存在这样一个驱动对象,该对象内所包含的就是当前所加载驱动自身的一些 ...