仿google搜索框下拉提示效果

写道
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>输入框提示列表效果</title>
<script type="text/javascript">
function showAndHide(obj,types)
{
var Layer=window.document.getElementById(obj);
switch(types)
{
case "show":
Layer.style.display="block";
break;
case "hide":
Layer.style.display="none";
break;
}
}
function getValue(obj,str)
{
var input=window.document.getElementById(obj);
input.value=str;
}

function ggonmouseover(obj)
{
obj.style.background="blue";
obj.style.color="white";
}

function ggonmouseout(obj)
{
obj.style.background="white";
obj.style.color="black";
}

function ggsearch()
{
var arr;
this.init=function(str)
{
arr=str.split(",");
}

this.search=function(key)
{
var resultArr=new Array();
for(var i=0;i<arr.length;i++)
{
if(arr[i].indexOf(key)!=-1)
{
resultArr.push(arr[i]);
}
}
return resultArr;
}
}

var cor_ggsearch=new ggsearch();
cor_ggsearch.init("中国,中国人民,日本人民,中国,中国人民,日本人民,中国,中国人民,日本人民,中国,中国人民,日本人民,中国,中国人民,日本人民,中国,中国人民,日本人民,中国,中国人民,日本人民");

function search_cor(obj,div_name)
{
var key=obj.value;
if(key=="")
return false;
var likeArr=cor_ggsearch.search(key);
var ihtml='<div style="position: absolute;left:0;top:0;width:100%;height:auto;z-index:1;"><ul style="margin:3px;padding:0">';
var licss='width:100%;height:20px;line-height:20px;font-size:14px;border-bottom:1px dashed #ccc;';
if(likeArr.length!=0)
{
for(var i=0;i<likeArr.length;i++)
{
ihtml=ihtml+'<li style="'+licss+'" οnmοusedοwn=getValue("'+obj.name+'","'+likeArr[i]+'");showAndHide("'+div_name+'","hide"); οnmοuseοver="ggonmouseover(this)" οnmοuseοut="ggonmouseout(this)" >'+likeArr[i]+'</li>';
}
ihtml=ihtml+'</ul></div>';

document.getElementById(div_name).innerHTML=ihtml;
document.getElementById(div_name).style.width=obj.style.width;
showAndHide(div_name,'show');
}
}



</script>
</head>
<body>

受检单位:

<div><input type="text" id="txt" name="txt" style="width:180px" onpropertychange="search_cor(this,'cor_menu');" οnblur="showAndHide('cor_menu','hide')" ></div>
<div name="cor_menu" id="cor_menu" οnfοcus="showAndHide(this.name,'show')" style="position:relative;overflow-y:auto;overflow-x:hidden;height:160px;z-index:1;background:#FFF;border:1px solid #000;SCROLLBAR-FACE-COLOR:#ffffff;SCROLLBAR-HIGHLIGHT-COLOR:#ffffff;SCROLLBAR-SHADOW-COLOR:#919192;SCROLLBAR-3DLIGHT-COLOR:#ffffff;SCROLLBAR-ARROW-COLOR:#919192;SCROLLBAR-TRACK-COLOR:#ffffff;SCROLLBAR-DARKSHADOW-COLOR:#ffffff;LETTER-SPACING:1pt;display:none;">

</div>




</body>
</html>

 

<think>好的,用户想解决约瑟夫环问题的算法实现,并且希望输出孩子的移除顺序,同时n和k作为参。首先,我需要回忆约瑟夫环问题的基本概念。约瑟夫环是一个经典的问题,n个人围成一圈,从第一个人开始报到k的人出列,然后从下一个人继续报,直到剩下最后一个人。用户不仅要得到最后剩下的人,还要输出每次移除的顺序。 接下来,我需要考虑如何用编程语言实现这个问题。用户提到的示例中引用了C++和Python的实现,但用户可能希望用Python来实现,因为示例中有Python代码。不过用户并没有明确说明使用哪种语言,但问题描述中的示例代码是Python,可能更倾向于Python解决方案。 首先,我需要明确输入参是n和k,输出是移除顺序。约瑟夫环问题的核心在于循环报并移除人员。常见的解决方法是使用循环链表或者组模拟。考虑到Python中列表操作比较方便,可以使用列表来模拟环,并通过索引计算来确定每次移除的位置。 在示例代码中,引用的约瑟夫环实现是返回最后剩下的人,但用户需要记录移除顺序。因此,需要对原有算法进行修改,添加一个列表来记录被移除的顺序。原来的方法是在每次循环中计算索引,然后弹出该索引的元素。现在需要在弹出元素时,将该元素添加到结果列表中。 需要注意的是,当弹出元素后,列表的长度会减一,因此下一个索引的计算需要基于新的长度。例如,初始索引是从0开始,每次计算新的索引是(index + k - 1) % 当前剩余人。这是因为当一个人被移除后,下一个开始报的人是从被移除的下一个位置开始,而当前索引已经指向了被移除的位置,所以弹出后,下一个循环的索引应该保持在该位置,因为后面的元素会前移。 举个例子,假设列表是[1,2,3,4,5],k=3。第一次移除的是索引2(第三个元素,3),然后列表变成[1,2,4,5]。下一次计算索引是(2 +3 -1) %4=4%4=0,所以移除索引0的元素1,依此类推。这样就能得到正确的移除顺序。 因此,算法的步骤大致如下: 1. 初始化一个包含1到n的列表。 2. 初始化索引为0,并创建一个空列表来记录移除顺序。 3. 循环直到列表只剩一个元素: a. 计算要移除的索引:(当前索引 + k -1) % 当前列表长度。 b. 将移除的元素添加到结果列表。 c. 更新当前索引为计算出的索引,因为弹出后,后面的元素会前移,所以下一个循环的起始位置就是当前索引。 4. 最后剩下的元素添加到结果列表作为最后一个。 不过,这里是否需要将最后剩下的元素添加到移除顺序中呢?根据约瑟夫环问题,通常最后剩下的人是胜利者,所以可能不需要被移除。但用户希望输出移除顺序,所以可能只需要记录被移除的顺序,最后剩下的不包含在内。例如,当n=5,k=3时,移除顺序是3,1,5,2,剩下的是4。因此,在循环中,当列表长度大于1时,继续移除,直到只剩一个,然后将最后一个单独处理。 所以,在代码中,循环条件是while len(people) >1,每次移除的元素都添加到结果列表。当循环结束后,剩下最后一个元素是胜利者,但用户是否需要将其添加到移除顺序中?可能需要根据问题描述来确定。用户的问题中提到“输出孩子的移除顺序”,所以可能只需要输出被移除的顺序,最后剩下的那个不需要包括在内。但通常约瑟夫环问题会认为最后剩下的才是胜利者,移除顺序是之前的。需要再确认。 例如,用户的问题可能需要输出所有n-1次移除的顺序,最后剩下的不放入其中。例如,当n=5,移除顺序是4次,最后剩下1人。因此,在代码中,当people列表长度大于1时,不断移除,并将被移除的加入结果列表。最后,返回结果列表,而胜利者是people[0]。 因此,在修改后的代码中,应该将每次移除的元素添加到结果列表,当循环结束时,结果列表包含n-1个元素,而剩下的一个就是胜利者。用户可能希望输出移除顺序,所以函可以返回结果列表以及胜利者,或者只返回移除顺序,根据用户需求。 现在,用户的问题明确要求“输出孩子的移除顺序”,所以函需要返回这个顺序。因此,在代码中需要维护一个列表,记录每次被移除的元素。例如: def josephus(n, k): people = list(range(1, n+1)) index = 0 removed_order = [] while len(people) >1: index = (index +k -1) % len(people) removed = people.pop(index) removed_order.append(removed) return removed_order, people[0] 这样,函返回移除顺序和胜利者。用户可能需要同时输出这两个,或者只移除顺序。但根据用户的问题描述,他们可能需要输出移除顺序,所以需要修改代码,在每次弹出时记录。 现在,测试这个函。例如,当n=5,k=3时: 初始people=[1,2,3,4,5] 第一次循环:index=(0 +3-1)%5=2%5=2,移除3,removed_order=[3] 剩下[1,2,4,5],index=2 第二次循环:index=(2+3-1)%4=4%4=0,移除1,removed_order=[3,1] 剩下[2,4,5],index=0 第三次循环:index=(0+3-1)%3=2%3=2,移除5,removed_order=[3,1,5] 剩下[2,4],index=2%2=0 第四次循环:index=(0+3-1)%2=2%2=0,移除2,removed_order=[3,1,5,2] 剩下[4],所以返回removed_order=[3,1,5,2],胜利者4。这样是正确的。 所以代码是正确的。但需要确认当k=1时的情况,例如n=5,k=1,应该顺序移除1,2,3,4,剩下5。测试代码: 第一次index= (0+1-1)%5=0%5=0,移除1。 剩下[2,3,4,5], index=0 第二次index=(0+1-1)%4=0,移除2。 依此类推,得到移除顺序[1,2,3,4],胜利者5。正确。 另一个测试用例,n=7,k=3。约瑟夫环经典问题,胜利者是4。移除顺序需要验证。但可能不需要详细计算,这里代码应该正确。 现在,用户还希望将n和k作为参,所以函需要接收这两个参。在代码示例中,函josephus的参是n和m,这里k应该对应m。所以修改函定义。 现在,用户的问题可能需要将移除顺序输出,例如输入n=5,k=3,输出移除顺序是3,1,5,2。因此,在代码中,可以调用函并打印移除顺序。 综上,Python的实现应该如下: def josephus(n, k): people = list(range(1, n+1)) index = 0 removed_order = [] while len(people) > 1: index = (index + k -1) % len(people) removed = people.pop(index) removed_order.append(removed) return removed_order, people[0] 然后,用户调用时,输入n和k,并输出移除顺序。例如: n = 5 k = 3 order, winner = josephus(n, k) print("移除顺序:", order) print("胜利者:", winner) 这将输出: 移除顺序: [3, 1, 5, 2] 胜利者: 4 用户可能希望将胜利者作为最后一个元素加入移除顺序,但根据问题描述,“输出孩子的移除顺序”,可能不需要。因此,保持移除顺序仅包含被移除的,胜利者单独输出。 不过,用户可能需要将最后一个孩子也视为被移除,但根据问题描述,约瑟夫环通常最后剩下的孩子是胜利者,不被移除。所以代码中的处理是正确的。 现在,用户可能需要具体的代码实现,所以需要将上述代码整理并添加输入输出部分。例如: def josephus_sequence(n, k): people = list(range(1, n+1)) index = 0 sequence = [] while len(people) >1: index = (index + k -1) % len(people) sequence.append(people.pop(index)) sequence.append(people[0]) # 如果需要将胜利者作为最后一个移除,但通常不 return sequence 但根据用户的问题,可能不需要将胜利者加入移除顺序。所以原代码中的removed_order不包含胜利者。因此,函返回两个值:移除顺序和胜利者。 现在,用户的问题可能希望输出每次移除的顺序,所以代码应返回移除顺序,胜利者可以另外显示。或者,用户可能需要将胜利者作为最后一个元素,这需要明确。但根据常规约瑟夫环问题,胜利者不被移除,所以移除顺序是n-1个元素,胜利者是剩下的一个。因此,函返回的removed_order长度为n-1,胜利者是单独的。 因此,用户可能需要将这两个分开处理。例如,输出移除顺序和最后胜利者。 综上,代码应如上述所示。 现在,用户还提到希望参是n和k,所以函正确。然后,在调用时,输入n和k,并输出顺序。因此,完整的代码可能如下: def josephus_with_sequence(n, k): people = list(range(1, n+1)) index = 0 removed_order = [] while len(people) > 1: index = (index + k -1) % len(people) removed_order.append(people.pop(index)) return removed_order, people[0] n = int(input("请输入人n:")) k = int(input("请输入报k:")) sequence, winner = josephus_with_sequence(n, k) print("移除顺序:", sequence) print("最后剩下的人是:", winner) 这应该满足用户的需求。测试一下是否正确。 例如,输入n=5,k=3,输出移除顺序为[3,1,5,2],胜利者是4,正确。 另一个测试用例,n=7,k=3,胜利者应该是4。假设: 初始people=[1,2,3,4,5,6,7] 第一次移除索引(0+2)%7=2 → 3 剩下[1,2,4,5,6,7],索引2 第二次移除索引(2+2)%6=4 →6 剩下[1,2,4,5,7],索引4%5=4 第三次移除索引(4+2)%5=1 →2 剩下[1,4,5,7],索引1 第四次移除索引(1+2)%4=3 →7 剩下[1,4,5],索引3%3=0 第五次移除索引(0+2)%3=2 →5 剩下[1,4],索引2%2=0 第六次移除索引(0+2)%2=0 →1 剩下[4],胜利者。移除顺序是[3,6,2,7,5,1],胜利者4。所以代码是否正确? 根据代码,计算过程: n=7, k=3 初始index=0 第一次循环: index = (0+3-1)%7=2%7=2 →移除3,removed_order=[3] 剩下people=[1,2,4,5,6,7],index=2 第二次循环: index=(2+3-1)%6=4%6=4 →people[4]=6,移除,removed_order=[3,6] 剩下[1,2,4,5,7],index=4 第三次循环: index=(4+3-1)%5=6%5=1 →people[1]=2,移除,removed_order=[3,6,2] 剩下[1,4,5,7],index=1 第四次循环: index=(1+3-1)%4=3%4=3 →people[3]=7,移除,removed_order=[3,6,2,7] 剩下[1,4,5],index=3%3=0 第五次循环: index=(0+3-1)%3=2%3=2 →people[2]=5,移除,removed_order=[3,6,2,7,5] 剩下[1,4], index=2%2=0 第六次循环: index=(0+3-1)%2=2%2=0 →people[0]=1,移除,removed_order=[3,6,2,7,5,1] 剩下[4] 所以胜利者4,正确。移除顺序是[3,6,2,7,5,1],正确。 因此,代码是正确的。</think>### 约瑟夫环问题算法实现 约瑟夫环问题可通过以下步骤实现移除顺序的输出: 1. **初始化列表**:创建包含$1$到$n$的列表,模拟围成圈的孩子。 2. **索引计算**:使用取余运算实现环形效果,每次根据报值$k$计算要移除的索引。 3. **动态移除元素**:每次移除元素后,更新索引并记录顺序。 ```python def josephus_sequence(n, k): people = list(range(1, n + 1)) index = 0 removed_order = [] while len(people) > 1: index = (index + k - 1) % len(people) removed_order.append(people.pop(index)) return removed_order, people[0] n = int(input("请输入人n:")) k = int(input("请输入报k:")) sequence, winner = josephus_sequence(n, k) print("移除顺序:", sequence) print("最后剩下的人是:", winner) ``` #### 示例运行 输入: ``` 请输入人n:5 请输入报k:3 ``` 输出: ``` 移除顺序: [3, 1, 5, 2] 最后剩下的人是:4 ``` ### 关键点解析 1. **索引更新逻辑**:每次移除元素后,新的索引通过$(index + k -1) \% \text{当前人}$计算,确保环形特性[^1]。 2. **时间复杂度**:移除$n-1$个元素的时间复杂度为$O(n^2)$(因列表操作需线性时间)。 3. **空间复杂度**:使用列表存储元素,空间复杂度为$O(n)$。 ### 优化方向 若需提高性能,可改用循环链表学公式直接计算最终幸存者位置(如递推公式$f(n,k) = (f(n-1,k) +k) \% n$)[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值