小编IVl*_*lad的帖子

我想构建一个登录表单,该表单显示在我站点中每个页面的侧栏中.如果用户输入了错误的用户/通行证,我希望错误显示在此表单上方(页面的其余部分保持原样),如果他成功登录,我希望表单更改为列表有关用户的信息(同样,页面的其余部分与登录前相同).我正在使用带有默认Internet应用程序模板的MVC 3 Web应用程序项目.我有这个:

_Layout.cshtml

@{ 
    if (User.Identity.IsAuthenticated)
    {
        Html.RenderAction("ShowUserInfo", "User");
    }
    else
    {
        Html.RenderAction("LogIn", "User");   
    }        
}

UserController的

    [ChildActionOnly]
    public PartialViewResult ShowUserInfo()
    {
        // populate loggedInInfo from database based on
        // User.Identity.Name
        return PartialView("_LoggedInInfo", loggedInInfo);
    }

    private ActionResult RedirectToPrevious(string returnUrl)
    {
        if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
            && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
        {
            return Redirect(returnUrl);
        }
        else
        {
            return RedirectToAction("index", "");
        }
    }

    [ChildActionOnly]
    public PartialViewResult LogIn()
    {
        return PartialView("_LogInForm");
    }

    //
    // POST: /User/LogIn

    [HttpPost]
    public ActionResult LogIn(LogInModel …

考虑以下与 CIFAR-10 数据集上的 Keras 顺序模型配合使用的代码。文章末尾给出了背景：

import tensorflow as tf
from sklearn.datasets import fetch_openml
from sklearn.utils import shuffle

data, targets = shuffle(*fetch_openml('CIFAR_10', version=1, return_X_y=True))
train_sz = 50000
X_train, X_test, y_train, y_test = data[:train_sz, :], data[train_sz:, :], np.asarray(targets[:train_sz], dtype=np.int), np.asarray(targets[train_sz:], dtype=np.int)

model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(X_train.shape[1],)))
model.add(tf.keras.layers.Dense(64, activation='relu'))
model.add(tf.keras.layers.Dense(10))
model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer='adam')

s = 0
for _ in range(500):
    for i in range(100):
        layers = []
        for layer in model.get_weights():
            layers.append(np.random.normal(0, 1, layer.shape))
        model.set_weights(layers)
        eval = model.evaluate(X_train, y_train)
        s += eval
        print(f'Done {i}')
print(s) …

给定n整数，是有一个O(n)或O(n log n)能够计算可通过将操作员获得的数学表达式的最大值算法-，+，*和给定的数字之间括号？仅假定运算符的二进制变体，因此不取一元减，除非需要，请在第一个元素之前。

例如，给定-3 -4 5，我们可以构建表达式(-3) * (-4) * 5，其值为60，并且可能的最大值。

背景：

前一段时间，我在研究遗传算法时偶然发现了这个问题，并了解到可以使用经典遗传算法非常简单地解决它。但是，它运行缓慢，并且理论上只是简单的，因为代码在实践中变得很丑陋（评估表达式，检查方括号的正确放置等）。此外，我们也不保证找到绝对最大值。

遗传算法的所有这些缺点让我感到纳闷：既然我们不必担心除法问题，是否有办法以更经典的方法（例如动态编程或贪婪策略）有效地做到这一点？

更新：

这是一个F＃程序，它实现了@Keith Randall提出的DP解决方案以及我的改进，我在对他的帖子的评论中写道。这是非常低效的，但是我坚持认为它是多项式并且具有三次复杂性。它可以在几秒钟内运行约50个元素数组。如果以完全命令式的方式编写，可能会更快，因为可能会浪费大量时间来构建和遍历列表。

open System
open System.IO
open System.Collections.Generic

let Solve (arr : int array) =
    let memo = new Dictionary<int * int * int, int>()

    let rec Inner st dr last = 
        if st = dr then 
            arr.[st]
        else
            if memo.ContainsKey(st, dr, last) then
                memo.Item(st, dr, last)
            else …

我在 C# 中正确实现 Bentley-Ottmann 算法时遇到了一些麻烦。我试图根据这里的伪代码来实现它。我在下面发布了我的主要代码。假设 myBST和PriorityQueueclasses 实现正确，您是否发现代码有任何问题？

没有错误，但不是所有的交点都找到了，只有一些。我的猜测是else代码部分有错误（当前事件是交点时）。通过交换 BST 中两个段的位置，我不确定伪代码是什么意思。我这样做的方式好吗？因为最终，两者在 BST 中并没有真正交换。我也不能只是改变他们的位置，因为这可能会破坏 BST 属性。

另外，我是否正确假设段在 BSTY中按其左端点的坐标排序？

我注意到的另一个我似乎无法追踪的错误是，有时要点(0, 0)进入eventList. 在没有交集的情况下(0, 0)输出Geometry.Intersects，但在这种情况下，if条件应该阻止它被添加。我不知道它是如何进入的。如果我eventList在添加一个点后打印 的内容，则(0, 0)永远不会出现。如果我在提取和弹出元素后打印内容，(0, 0)有时会出现。这可能与Pop()混淆引用的方法有什么关系，还是我的PriorityQueue实现中绝对有问题？

如果需要，我也可以展示我对 BST 和优先级队列的实现。

static class BentleyOttman
{
    private static void AddIntersectionEvent(PriorityQueue eventList, Segment segEv, Segment segA, SegPoint i)
    {
        i.IntersectingSegments = new Tuple<Segment, Segment>(segEv, segA);
        i.Type = …

正如问题所说，我想确认计数排序算法是否是就地排序算法。

维基百科将就地算法描述为

在计算机科学中，就地算法（或拉丁语中的 in situ）是一种使用具有少量、恒定额外存储空间的数据结构来转换输入的算法。当算法执行时，输入通常会被输出覆盖。非就地算法有时被称为非就地或异地（或拉丁语中的异地）。

稳定的排序算法维护具有相同键（即值）的记录的相对顺序。也就是说，如果每当有两个记录 R 和 S 具有相同的键并且 R 在原始列表中出现在 S 之前，则排序算法是稳定的，在排序列表中 R 将出现在 S 之前。

以及下面的某处计数排序页面：

如上所述，计数排序不是就地算法；即使忽略计数数组，它也需要单独的输入和输出数组。

如果我们假设计数排序算法为：

countsort(){
    for i = 0 .... n  //where n is size of input array arr[]
        countArr[ arr[i] ] += 1
    //and then traverse countArr[] and rewrite arr[] with sorted values where value>0

那为什么这不是一个稳定且到位的排序呢？

假设输入由和由 字符key data表示，那么对于以下数据：numeralssatellite data

arr[] = { 1a,1b,1c,2z,5c,6c,7e,8q }  // keeping in mind only keys are sorted

这个算法不会遍历 1a 然后 1b …

我正在阅读冈崎的纯功能数据结构,并尝试做一些练习.其中之一是证明二项式堆merge需要O(log n)时间在堆中n的节点数量.

functor BinomialHeap (Element:ORDERED):HEAP=
struct
  structure Elem=Element
  datatype Tree = Node of int*Elem.T*Tree list
  type Heap = Tree list
  fun link (t1 as Node (r,x1,c1), t2 as Node (_,x2,c2))=
    if Elem.leq(x1,x2)
    then Node (r+1,x1,t2::c1)
    else Node (r+1,x2,t1::c2)
  fun insTree (t,[])=[t]
     |insTree (t,ts as t'::ts')=
        if rank t < rank t' then t::ts else insTree(link(t,t'),ts')
  fun insert (x,ts)=insTree(Node(0,x,[]),ts) (*just for reference*)
  fun merge (ts1,[])=ts1
     |merge ([],ts2)=ts2
     |merge (ts1 as t1::ts1', ts2 as …

我无法弄清楚为什么Django无法在我的应用程序中找到请求的URL.

这是我得到的错误代码:

 Using the URLconf defined in littlelogsms.urls, Django tried these URL patterns, in this order:
^admin/
^$
The current URL, success/, didn't match any of these.

这是我的sms.urls.py文件:

from django.conf.urls import url

from sms import views

urlpatterns = [
    url(r'^success/$', views.success, name='success'),
    url(r'^$', views.index, name='index')
]

这是应用程序urls.py文件:

from django.conf.urls import include, url
from django.contrib import admin


urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'^$', include('sms.urls')),
]

我找不到我正在犯的错误.有任何想法吗？

给定一组n点,我们能找到三个点来描述最小面积的三角形O(n^2)吗？如果是,如何,如果没有,我们能做得更好O(n^3)吗？

我发现一些论文表明这个问题至少和要求找到三个共线点(一个面积为0的三角形)的问题一样困难.这些论文O(n^2)通过将其简化为三和问题的实例来描述该问题的解决方案.然而,我无法找到任何我感兴趣的解决方案.请参阅此(查找一般位置)以获取此类论文以及有关3-sum的更多信息.

我已经编写了这两种排序算法,看起来选择排序比合并排序更快,这肯定不是正确的吗？我的测试数据是10个大小为5000到50000的随机数组,其中数组中最大可能的数字是100这是我的选择排序实现:`int i,j,iMin; int n = c.length;

    startTime = System.currentTimeMillis();
    for (i = 0; i < n - 1; i++) 
        {
        iMin = i;
            for (j = i + 1; j < n; j++)

                if (c[j] < c[iMin])
                {
                    iMin = j;
                    if(sorting)
                    {
                    theDelay();
                    }
                }
                if (iMin != i) 
                {
                    swap(c, iMin, i);
                    if(sorting)
                    {
                    theDelay();
                    }
                }

        }
   endTime = System.currentTimeMillis();
   overallTime = endTime - startTime;
  // System.out.println(overallTime);

}`

该theDelay()方法只是延迟排序算法在其中运行的线程,以便可视化图形可以绘制到JPanel以显示操作中的排序,在此测试用例中它被忽略,因此不会影响我的排序时间.

这是我的合并排序实现:

public void mergeSort(int[] d) throws …

有两个排序的数组A,B长度相等,A按升序排序,数组B按降序排序.

A = {1, 3, 7, 7, 7, 7}
B = {7, 7, 5, 5, 5, 4}

我的任务是找到两个元素,一个来自A和来自其中B,以便它们的总和最大.

有一个约束,我可以选择任何元素,A但我必须从B这样的顺序中B选择元素,即数组元素的索引应该大于所选元素的索引A.

在这种情况下,可以选择的最大总和是12.我是O(n)通过简单地从左到右迭代完成的.

我想知道是否有更好,更有效的方法来找到这两个元素的总和.