文档章节

再译《A *路径搜索入门》之五

放个屁
 放个屁
发布于 2015/06/11 12:02
字数 6787
阅读 54
收藏 4
点赞 0
评论 0

施上的注意事

Notes on Implementation

 

在您了解了基本的方法,当你写自己的程序,有一些外的事情要考。下面给出C ++Blitz Basic写的程序,其他有效

Now that you understand the basic method, here are some additional things to think about when you are writing your own program. Some of the following materials reference the program I wrote in C++ and Blitz Basic, but the points are equally valid in other languages.

 

1.其他防止碰撞):如果你碰巧仔看我的演示,你会注意到它完全忽略了屏幕上的其他该单直接通过对方。根据游可能是可以的,或者它可能是不可以的。如果你想考其他路径搜索算法,并彼此走,另一个,我建你只考要么在路径的算,理它的当前位置停止或相路径搜索单元。于正在相元,防止碰撞可以通过惩罚沿着各自的路径点,从而鼓励路径搜索找到一个替代径(2描述)。

1. Other Units (collision avoidance): If you happen to look closely at my example code, you will notice that it completely ignores other units on the screen. The units pass right through each other. Depending on the game, this may be acceptable or it may not. If you want to consider other units in the pathfinding algorithm and have them move around one another, I suggest that you only consider units that are either stopped or adjacent to the pathfinding unit at the time the path is calculated, treating their current locations as unwalkable. For adjacent units that are moving, you can discourage collisions by penalizing nodes that lie along their respective paths, thereby encouraging the pathfinding unit to find an alternate route (described more under #2).

 

如果你选择认为是移和不相其他,你将需要开一种方法来预测会在任何定的时间点,使他得到适当回避。否,你最可能会用异的路径,其中锯齿状,以避免其他,不存在了。

If you choose to consider other units that are moving and not adjacent to the pathfinding unit, you will need to develop a method for predicting where they will be at any given point in time so that they can be dodged properly. Otherwise you will probably end up with strange paths where units zig-zag to avoid other units that aren't there anymore.

 

当然,需要开一些碰撞检测,因再好的路径是在它的算方法,事情可能随时间而改。当生碰撞位必要么算新的路径,或者如果其他元被移,它不是一个迎面碰撞,等待其他继续与当前路径之前到步骤闪开。

You will also, of course, need to develop some collision detection code because no matter how good the path is at the time it is calculated, things can change over time. When a collision occurs a unit must either calculate a new path or, if the other unit is moving and it is not a head-on collision, wait for the other unit to step out of the way before proceeding with the current path.

 

些技巧可能是足以你开始。如果您想了解更多,里有一些你可能会发现有用接:

These tips are probably enough to get you started. If you want to learn more, here are some links that you might find helpful:

 

角色的向行

http://www.red3d.com/cwr/steer/

克雷格雷的方向上的工作是从路径搜索有点不同,但它可以与路径搜索集成,以做出更完整的移和防撞系

Steering Behavior for Autonomous Characters: Craig Reynold's work on steering is a bit different from pathfinding, but it can be integrated with pathfinding to make a more complete movement and collision avoidance system.

 

计算机游戏中的长转向

http://ducati.doc.ntu.ac.uk/uksim/uksim%2704/Papers/Simon%20Tomlinson-%2004-20/paper04-20%20CR.pdf

向和路径搜索文学的一个有趣的调查是一个PDF文件。

The Long and Short of Steering in Computer Games: An interesting survey of the literature on steering and pathfinding. This is a pdf file.

 

协调运行:

http://www.gamasutra.com/features/game_design/19990122/movement_01.htm

由帝国代的设计师戴夫·乍首先在两部分成的系列形成和文章基于的运

Coordinated Unit Movement: First in a two-part series of articles on formation and group-based movement by Age of Empires designer Dave Pottinger.

 

实现协调

http://www.gamasutra.com/view/feature/3314/implementing_coordinated_movement.php

戴夫·乍的两部分成的系列第二。

Implementing Coordinated Movement: Second in Dave Pottinger's two-part series.

 

2.的地形成本:在本教程中,我的程序随行,地形仅仅是两件事情之一走和不走。但是,如果你有地形就是走,但在更高的移动成本?沼,丘陵,地下城的楼梯,等等 - 都是地形是适合步行的所有例子,但在成本要比平坦,开地高。似地,道路可能具有低的运行成本比周的地形。

2. Variable Terrain Cost: In this tutorial and my accompanying program, terrain is just one of two things – walkable or unwalkable. But what if you have terrain that is walkable, but at a higher movement cost? Swamps, hills, stairs in a dungeon, etc. – these are all examples of terrain that is walkable, but at a higher cost than flat, open ground. Similarly, a road might have a lower movement cost than the surrounding terrain.

 

问题很容易加入,当你算任何点的G在地形成本理。只是金的成本添加到这样点。在A *路径搜索算法已写入找最低成本路径,应该很容易地问题。在简单的例子中,我描述的,当地只是走和不走,A *找最短,最直接的途径。但是,在可成本的地形境,以最少的成本路径可能行走了较长的距离 - 就像把周的沼道路,而不是直接通它。

This problem is easily handled by adding the terrain cost in when you are calculating the G cost of any given node. Simply add a bonus cost to such nodes. The A* pathfinding algorithm is already written to find the lowest cost path and should handle this easily. In the simple example I described, when terrain is only walkable or unwalkable, A* will look for the shortest, most direct path. But in a variable-cost terrain environment, the least cost path might involve traveling a longer distance – like taking a road around a swamp rather than plowing straight through it.

 

一个有趣的附加考是什么专业人士称之“影响映射。”正如上述的可成本的地形,你可以建一个外的分系,并将其用到AI的路径。想一下,你有一堆山区保护位地。每当算机通通某人送的路径上,它被重。如果你愿意,你可以建一个影响地处罚节点,其中大量的屠正在生。会教电脑偏好安全的路径,并帮助它避免愚蠢的情况下,它不断通特定的路径出兵,只是因它是短(但更危)。

An interesting additional consideration is something the professionals call "influence mapping." Just as with the variable terrain costs described above, you could create an additional point system and apply it to paths for AI purposes. Imagine that you have a map with a bunch of units defending a pass through a mountain region. Every time the computer sends somebody on a path through that pass, it gets whacked. If you wanted, you could create an influence map that penalized nodes where lots of carnage is taking place. This would teach the computer to favor safer paths, and help it avoid dumb situations where it keeps sending troops through a particular path, just because it is shorter (but also more dangerous).

 

另一种可能的用途是惩罚沿着附近的移台的路径点。之一的A *的缺点之一是,当一元的所有尝试找到的似位置的路径,通常有一个著程度的重叠,如一个或多个试图利用相同或似的路由到它的目的地。添加一个点球已被其他位声称“点将有助于确保一定程度的分离,并减少冲突。不要把这样点作走,但是因愿意多台设备才能够挤过紧通道鱼贯,如果有必要的。此外,你应该处罚,附近的路径搜索单元,不是所有路径的路径,否你会得到奇怪的避行,避免元的元,都不及他的路径。此外,你应该惩罚谎言沿着一条路径,而不是已经访问过并留下以前的路径点的当前和未来的部分道路点。

Yet another possible use is penalizing nodes that lie along the paths of nearby moving units. One of the downsides of A* is that when a group of units all try to find paths to a similar location, there is usually a significant amount of overlap, as one or more units try to take the same or similar routes to their destinations. Adding a penalty to nodes already 'claimed' by other units will help ensure a degree of separation, and reduce collisions. Don't treat such nodes as unwalkable, however, because you still want multiple units to be able to squeeze through tight passageways in single file, if necessary. Also, you should only penalize the paths of units that are near the pathfinding unit, not all paths, or you will get strange dodging behavior as units avoid paths of units that are nowhere near them at the time. Also, you should only penalize path nodes that lie along the current and future portion of a path, not previous path nodes that have already been visited and left behind.

 

3.理未探索区域:你曾一款PC算机是准确的知道路如何走,即使地没有探索?根据不同的游,那路径搜索太好可以是不现实的。幸运的是,是可以很容易理的问题

3. Handling Unexplored Areas: Have you ever played a PC game where the computer always knows exactly what path to take, even though the map hasn't been explored yet? Depending upon the game, pathfinding that is too good can be unrealistic. Fortunately, this is a problem that is can be handled fairly easily.

 

答案是建一个独立的“已知的通列的每个玩家以及电脑对手的(每个玩家,不是每一个 - 那将需要更多的算机内存)。每个列将包含有关玩家已探索区域的信息,与地的其他部分假设为适宜步行,直到明并非如此。使用种方法,位将漫步死角,使似的错误选择,直到他们发现的路。一旦地探索,然而,路径搜索会正常工作。

The answer is to create a separate "knownWalkability" array for each of the various players and computer opponents (each player, not each unit -- that would require a lot more computer memory). Each array would contain information about the areas that the player has explored, with the rest of the map assumed to be walkable until proven otherwise. Using this approach, units will wander down dead ends and make similar wrong choices until they have learned their way around. Once the map is explored, however, pathfinding would work normally.

 

4.更平滑的路径:A *会自动给出最短,成本最低的路径,它不会自动给出看起来最平滑的路径。看一看在我的(7算的例子最路径。在路径中,第一个步是下面,并开始方格的右。会不会我的道路更顺畅,如果第一步是正下方的起点,而不是方形的方格?

4. Smoother Paths: While A* will automatically give you the shortest, lowest cost path, it won't automatically give you the smoothest looking path. Take a look at the final path calculated in our example (in Figure 7). On that path, the very first step is below, and to the right of the starting square. Wouldn't our path be smoother if the first step was instead the square directly below the starting square?

 

有几种方法来解决问题。当你正在算路径,你可以处罚节点那里有方向的化,增加了处罚G扣分。或者,你可以通你的路径运行的算后,找在那里选择邻节点的地方会你看起来更好的路径。欲了解更多关于整个问题向更加逼真路径搜索,一个(免的,但需要注册)在Gamasutra.comMacro Pinter文章

There are several ways to address this problem. While you are calculating the path you could penalize nodes where there is a change of direction, adding a penalty to their G scores. Alternatively, you could run through your path after it is calculated, looking for places where choosing an adjacent node would give you a path that looks better. For more on the whole issue, check out Toward More Realistic Pathfinding, a (free, but registration required) article at Gamasutra.com by Marco Pinter.

 

5.非方格搜索区域:在我的例子中,我使用了一个简单的二方格布局。你并不需要使用种方法。你可以使用不规则的形状区域。想想棋风险,以及国家在那。你可以设计一个路径搜索方案行一。要做到一点,你需要建一个表,用于存邻的国家,并与移从一个国家到下一个相关的G。你需要拿出用于估H.其他一切会被理一在上面的例子中的方法。而不是使用相的方格,你会简单找相国家在表中增加新的目到开启列表

5. Non-square Search Areas: In our example, we used a simple 2D square layout. You don't need to use this approach. You could use irregularly shaped areas. Think of the board game Risk, and the countries in that game. You could devise a pathfinding scenario for a game like that. To do this, you would need to create a table for storing which countries are adjacent to which, and a G cost associated with moving from one country to the next. You would also need to come up with a method for estimating H. Everything else would be handled the same as in the above example. Instead of using adjacent squares, you would simply look up the adjacent countries in the table when adding new items to your open list.

 

,你可以建一个固定的地形路径的航点系。航点通常走的路径上的点,也在一个地牢道路或隧道的关。作戏设计者,你能先指定些路点。两个航点会被认为是“相”彼此是否有它的直线路径上没有障碍。由于在风险的例子,您将省在某种型的找表接信息,并用它生成新的开启列表。那么你会(可能通使用的直线距离)和H成本(可能使用从点到目的直线距离)记录相关的G。一切将继续如常。

Similarly, you could create a waypoint system for paths on a fixed terrain map. Waypoints are commonly traversed points on a path, perhaps on a road or key tunnel in a dungeon. As the game designer, you could pre-assign these waypoints. Two waypoints would be considered "adjacent" to one another if there were no obstacles on the direct line path between them. As in the Risk example, you would save this adjacency information in a lookup table of some kind and use it when generating your new open list items. You would then record the associated G costs (perhaps by using the direct line distance between the nodes) and H costs (perhaps using a direct line distance from the node to the goal). Everything else would proceed as usual.

 

阿米特Patel写了一个短的文章研一些替代品。于使用非方形的搜索区域上等距RPG搜索的另一个例子,看看我的文章两个次的A *路径搜索

Amit Patel has written a brief article delving into some alternatives. For another example of searching on an isometric RPG map using a non-square search area, check out my article Two-Tiered A* Pathfinding.

 

6.一些超速提示:当你开自己的A *程序,或者改我写的,你最发现路径搜索使用你的CPU时间大幅大,特是如果你对路径搜索的一台像的数目板和一个相当大的地。如果你网上读过西了,你会发现是真的,即使谁设计像星争霸或帝国代游专业人士。如果你看到的西开始放,由于路径搜索里有一些想法,可能会加快速度:

6. Some Speed Tips: As you develop your own A* program, or adapt the one I wrote, you will eventually find that pathfinding is using a hefty chunk of your CPU time, particularly if you have a decent number of pathfinding units on the board and a reasonably large map. If you read the stuff on the net, you will find that this is true even for the professionals who design games like Starcraft or Age of Empires. If you see things start to slow down due to pathfinding, here are some ideas that may speed things up:

 

一个小地或更少的位。

Consider a smaller map or fewer units.

 

不要做路径搜索以上几个时间。相反,把它放在一个列,它分布在几个游。如果你的游戏时,比如,每秒40个周期运行,没有人会注意到。但他发现,如果游似乎在一段时间放慢每一次当一束位都算路径在同一时间

Never do path finding for more than a few units at a time. Instead put them in a queue and spread them out over several game cycles. If your game is running at, say, 40 cycles per second, no one will ever notice. But they will notice if the game seems to slow down every once in a while when a bunch of units are all calculating paths at the same time.

 

使用更大的方格(或者任何你正在使用的形状)您的地减少了搜索以找到的路径的点的数。如果你有雄心,可以设计出了用于在不同的情况下,取决于路径的度的两个或更多个路径搜索专业人士做的,使用大面路径,然后切到更精的使用小的方格/地区搜索,当你接近目。如果你有趣在个概念,看看我的文章两个次的A *路径搜索

Consider using larger squares (or whatever shape you are using) for your map. This reduces the total number of nodes searched to find the path. If you are ambitious, you can devise two or more pathfinding systems that are used in different situations, depending upon the length of the path. This is what the professionals do, using large areas for long paths, and then switching to finer searches using smaller squares/areas when you get close to the target. If you are interested in this concept, check out my article Two-Tiered A* Pathfinding.

 

于更的路径,考是硬接到游戏预算好的路径。

For longer paths, consider devising precalculated paths that are hardwired into the game.

 

虑预处理地找出哪些域是从地的其余部分无法访问。我把域的“孤”。在现实中,他可以是岛屿或者其他任何地区,是另有围墙,无法访问。其中A *的缺点之一是,如果你告它来找路径等方面,它会搜索整个地,停,只有当每平方访问/点已通打开和关单处理。会浪大量的CPU时间。它可以通过预先确定哪些地区是不可访问(通洪水填充或似的程序),记录在某种型的列信息,然后在开始路径搜索前检查它来防。

Consider pre-processing your map to figure out what areas are inaccessible from the rest of the map. I call these areas "islands." In reality, they can be islands or any other area that is otherwise walled off and inaccessible. One of the downsides of A* is that if you tell it to look for paths to such areas, it will search the whole map, stopping only when every accessible square/node has been processed through the open and closed lists. That can waste a lot of CPU time. It can be prevented by predetermining which areas are inaccessible (via a flood-fill or similar routine), recording that information in an array of some kind, and then checking it before beginning a path search.

 

拥挤的,迷似的境中,考虑节标记不随地致的死角。些区域可以手动预先指定的地图编辑器,或者如果你有雄心的,你可以开一个算法,自动识别域。在定的死胡同区域点的任何集合可以予一个唯一的识别。然后路径搜索时,只停下来考一个死胡同区域点,如果起始位置或目的地恰好是在特定的死胡同区问题,你可以放心地忽略所有的死角。

In a crowded, maze-like environment, consider tagging nodes that don't lead anywhere as dead ends. Such areas can be manually pre-designated in your map editor or, if you are ambitious, you could develop an algorithm to identify such areas automatically. Any collection of nodes in a given dead end area could be given a unique identifying number. Then you could safely ignore all dead ends when pathfinding, pausing only to consider nodes in a dead end area if the starting location or destination happen to be in the particular dead end area in question.

 

7.维护开启列表:这实际上是A *路径搜索算法中最耗费时间的元素之一。您可以访问开启列表,都需要找到具有最小F方格。有几种方法可以做到一点。根据需要,你可以保存路径目,每次当你需要找到最小F的方格简单的遍整个列表。简单的,但路径很慢。可以通过维护一个排序的列表,每次需要最小F-成本方形时间只需抓住了第一个目从名得到改善。当我写我的程序,是我用第一种方法。

7. Maintaining the Open List: This is actually one of the most time consuming elements of the A* pathfinding algorithm. Every time you access the open list, you need to find the square that has the lowest F cost. There are several ways you could do this. You could save the path items as needed, and simply go through the whole list each time you need to find the lowest F cost square. This is simple, but really slow for long paths. This can be improved by maintaining a sorted list and simply grabbing the first item off the list every time you need the lowest F-cost square. When I wrote my program, this was the first method I used.

 

将工作得相当好小地,但它不是最快答案重的A *程序员谁想要真正的速度使用一种叫做二制堆,是我在我的代中使用。在我的经验种方法将是至少2-3倍的速度在大多数情况下,并且在几何形状更快(快10+次)上较长的路径。如果你主找更多关于二叉堆,看看我的文章,在A *路径搜索使用二制堆。

This will work reasonably well for small maps, but it isn't the fastest solution. Serious A* programmers who want real speed use something called a binary heap, and this is what I use in my code. In my experience, this approach will be at least 2-3 times as fast in most situations, and geometrically faster (10+ times as fast) on longer paths. If you are motivated to find out more about binary heaps, check out my article, Using Binary Heaps in A* Pathfinding.

 

另一种可能的瓶是你的方式明确和维护路径搜索调用之的数据构。我个人更喜所有列。点可以生成,记录并保存在一个动态的,面向象的方式,我发现建和象所需的时间量增加了外的开,不必要的水平会减慢速度。如果你使用数,不,你需要用之西了。你会想在种情况下的最后一件事就是花零时间做完一切了在调用路径搜索后,特是如果你有一个大的地

Another possible bottleneck is the way you clear and maintain your data structures between pathfinding calls. I personally prefer to store everything in arrays. While nodes can be generated, recorded and maintained in a dynamic, object-oriented manner, I find that the amount of time needed to create and delete such objects adds an extra, unnecessary level of overhead that slows things down. If you use arrays, however, you will need to clean things up between calls. The last thing you will want to do in such cases is spend time zero-ing everything out after a pathfinding call, especially if you have a large map.

 

我避免种开过创建一个二whichListXY),其指定在每个点上我的地任一开启列表或关列表上。路径搜索尝试之后,我不零数。相反,我在每一个路径搜索呼叫复位onClosedListonOpenList的价值观,每个路径尝试寻+5什么都增。通过这种方式,算法可以放心地忽略垃圾从以前的路径搜索尝试遗留任何数据。我也喜存放FGH列的成本。在种情况下,我只是写在任何先存在的价和不打清除,我做的。

I avoid this overhead by creating a 2d array called whichList(x,y) that designates each node on my map as either on the open list or closed list. After pathfinding attempts, I do not zero out this array. Instead I reset the values of onClosedList and onOpenList in every pathfinding call, incrementing both by +5 or something similar on each path finding attempt. This way, the algorithm can safely ignore as garbage any data left over from previous pathfinding attempts. I also store values like F, G and H costs in arrays. In this case, I simply write over any pre-existing values and don't bother clearing the arrays when I'm done.

 

在多个列存数据占用更多的内存,然如此,有一个衡。最,你应该使用什么方法,你是最舒服的。

Storing data in multiple arrays consumes more memory, though, so there is a trade off. Ultimately, you should use whatever method you are most comfortable with.

 

8. Dijkstra的算法:当A *通常被认为是最好的路径搜索算法(面的小咆哮),存在至少一个其它的算法有其用途 - Dijkstra算法。 Dijkstra的是基本相同的A *,除了没有启式(H终为0)。因它没有启式,它通在每一个方向同样扩大了搜索。正如你可能想象的,因为这Dijkstra算法通常是束了探索一个更大的区域之前目发现通常使得它比A *慢。

8. Dijkstra's Algorithm: While A* is generally considered to be the best pathfinding algorithm (see rant above), there is at least one other algorithm that has its uses - Dijkstra's algorithm. Dijkstra's is essentially the same as A*, except there is no heuristic (H is always 0). Because it has no heuristic, it searches by expanding out equally in every direction. As you might imagine, because of this Dijkstra's usually ends up exploring a much larger area before the target is found. This generally makes it slower than A*.

 

那么,什么使用它?有候,我不知道我的目位置是。假你有一个需要去得某种源的一些源收集装置。它可能知道几个源区域,但它希望去最近的一个。在里,Dijkstra的比A *更好,因不知道哪一个是最接近的。我唯一的选择是重复使用A *找到每一个的距离,然后选择这条道路。可能有无数似的情况,我知道那种位置,我可能会找的,想找到最近的一个,但不知道它在哪里或哪一个可能是最接近的。

So why use it? Sometimes we don't know where our target destination is. Say you have a resource-gathering unit that needs to go get some resources of some kind. It may know where several resource areas are, but it wants to go to the closest one. Here, Dijkstra's is better than A* because we don't know which one is closest. Our only alternative is to repeatedly use A* to find the distance to each one, and then choose that path. There are probably countless similar situations where we know the kind of location we might be searching for, want to find the closest one, but not know where it is or which one might be closest.

 

(待续)


© 著作权归作者所有

共有 人打赏支持
放个屁
粉丝 123
博文 177
码字总数 285078
作品 0
日本
程序员
再译《A *路径搜索入门》之流畅版??

A 路径搜索入门 帕特里克·莱斯特发表于2003年10月8日下午8点33人工智能 如果您发现文中有错误或问题(丢失的影像或文件,受损代码,不正确的文本格式等),导致无法阅读它时,请联系编辑,以...

放个屁
2015/06/17
0
0
再译《A *路径搜索入门》之一

※※※ 外语不好凑合着看吧,呵呵 ※※※ A 路径搜索入门 A Pathfinding for Beginners 帕特里克·莱斯特发表于2003年10月8日下午8点33人工智能 By Patrick Lester Published Oct 08 2003 08...

放个屁
2015/06/07
0
0
再译《A *路径搜索入门》之六

■延伸阅读 Further Reading 好了,现在你已具备了基础知识和一些先进的概念感。在这一点上,我建议你到涉水我的源代码。该软件包包含两个版本,一个是C ++的,一个是Blitz Basic的。两个版本...

放个屁
2015/06/10
0
0
【掘金小报】第八期 怎么用 Python 实现每秒百万级的请求?

掘金小报主打分享优质深度技术内容,技术内容分:前端、后端、Android、iOS、产品设计、工具资源和一些有趣的东西。 注意:与标题的相关的文章在后端分类下的:《[译] 用 Python 实现每秒百万...

膜法小编
2017/05/05
0
0
再译《A *路径搜索入门》之四

■在A 方法总结 Summary of the A Method 好了,现在你通过解释已经走了,让我们奠定了一步一步的方法,在同一个地方: Okay, now that you have gone through the explanation, let's lay ...

放个屁
2015/06/09
0
0
Scala 技术周刊 | 第 22 期

这里有最新的 Scala 社区动态、技术博文。 微信搜索 「scalacool」关注我们,及时获取最新资讯。 深度阅读 Status of the Collections Scala 集合重构进展 Akka 系列(十):Akka 集群之 Ak...

ScalaCool
2017/09/22
0
0
再译《A *路径搜索入门》之三

■继续搜索 Continuing the Search 要继续搜索,我们简单地选择在开启列表中具有最小F值的方块。然后,我们用选择方块作以下事情: To continue the search, we simply choose the lowest F ...

放个屁
2015/06/08
0
0
《鸡啄米VS2010/MFC编程入门》系列技术文章整理收藏

《鸡啄米VS2010/MFC编程入门》系列技术文章整理收藏 1VS2010/MFC编程入门之前言 http://www.lai18.com/content/410337.html 2VS2010/MFC编程入门之二(利用MFC向导生成单文档应用程序框架) ...

开元中国2015
2015/06/27
267
0
Linux基础篇之五基础命令 ---- 3

在linux中,我们经常需要查找某些文件,以及文件所在目录等。那么我们需要用到一些基本的文件查找类命令。 文件查找命令主要有以下几个: ·which 查看命令或可执行文件的完整路径 ·whereis...

ccs_Chan
2016/09/05
0
0
再译《A *路径搜索入门》之二

■路径评分 Path Scoring 计算出的路径时,确定要使用的方格的关键是下面的公式: The key to determining which squares to use when figuring out the path is the following equation: F ...

放个屁
2015/06/07
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

shell中的函数、shell中的数组、告警系统需求分析

shell中的函数 格式: 格式: function f_name() { command } 函数必须要放在最前面 示例1(用来打印参数) 示例2(用于定义加法) 示例3(用于显示IP) shell中的数组 shell中的数组1 定义数...

Zhouliang6
今天
2
0
用 Scikit-Learn 和 Pandas 学习线性回归

      对于想深入了解线性回归的童鞋,这里给出一个完整的例子,详细学完这个例子,对用scikit-learn来运行线性回归,评估模型不会有什么问题了。 1. 获取数据,定义问题     没有...

wangxuwei
今天
1
0
MAC安装MAVEN

一:下载maven压缩包(Zip或tar可选),解压压缩包 二:打开终端输入:vim ~/.bash_profile(如果找不到该文件新建一个:touch ./bash_profile) 三:输入i 四:输入maven环境变量配置 MAVEN_HO...

WALK_MAN
今天
0
0
33.iptables备份与恢复 firewalld的9个zone以及操作 service的操作

10.19 iptables规则备份和恢复 10.20 firewalld的9个zone 10.21 firewalld关于zone的操作 10.22 firewalld关于service的操作 10.19 iptables规则备份和恢复: ~1. 保存和备份iptables规则 ~2...

王鑫linux
今天
2
0
大数据教程(2.11):keeperalived+nginx高可用集群搭建教程

上一章节博主为大家介绍了目前大型互联网项目的系统架构体系,相信大家应该注意到其中很重要的一块知识nginx技术,在本节博主将为大家分享nginx的相关技术以及配置过程。 一、nginx相关概念 ...

em_aaron
今天
1
0
Apache Directory Studio连接Weblogic内置LDAP

OBIEE默认使用Weblogic内置LDAP管理用户及组。 要整理已存在的用户及组,此前办法是导出安全数据,文本编辑器打开认证文件,使用正则表达式获取用户及组的信息。 后来想到直接用Apache Dire...

wffger
今天
2
0
HFS

FS,它是一种上传文件的软件。 专为个人用户所设计的 HTTP 档案系统 - Http File Server,如果您觉得架设 FTP Server 太麻烦,那么这个软件可以提供您更方便的档案传输系统,下载后无须安装,...

garkey
今天
1
0
Java IO类库之BufferedInputStream

一、BufferedInputStream介绍 /** * A <code>BufferedInputStream</code> adds * functionality to another input stream-namely, * the ability to buffer the input and to * sup......

老韭菜
今天
0
0
STM 32 窗口看门狗

http://bbs.elecfans.com/jishu_805708_1_1.html https://blog.csdn.net/a1985831055/article/details/77404131...

whoisliang
昨天
1
0
Dubbo解析(六)-服务调用

当dubbo消费方和提供方都发布和引用完成后,第四步就是消费方调用提供方。 还是以dubbo的DemoService举例 -- 提供方<dubbo:application name="demo-provider"/><dubbo:registry address="z...

青离
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部